Example 1 with ArrayDataTypeType
use of org.omg.space.xtce.ArrayDataTypeType in project CCDD by nasa.
the class CcddXTCEHandler method setParameterDataType.
/**
********************************************************************************************
* Create the telemetry parameter data type and set the specified attributes
*
* @param spaceSystem
* space system
*
* @param parameterName
* parameter name; null to not specify
*
* @param dataType
* data type; null to not specify
*
* @param arraySize
* parameter array size; null or blank if the parameter isn't an array
*
* @param bitLength
* parameter bit length; null or empty if not a bit-wise parameter
*
* @param enumeration
* enumeration in the format <enum label>|<enum value>[|...][,...]; null to not
* specify
*
* @param units
* parameter units; null to not specify
*
* @param minimum
* minimum parameter value; null to not specify
*
* @param maximum
* maximum parameter value; null to not specify
*
* @param description
* parameter description; null to not specify
*
* @param description
* parameter description; null or blank to not specify
*
* @param stringSize
* size, in characters, of a string parameter; ignored if not a string or character
********************************************************************************************
*/
private void setParameterDataType(SpaceSystemType spaceSystem, String parameterName, String dataType, String arraySize, String bitLength, String enumeration, String units, String minimum, String maximum, String description, int stringSize) {
NameDescriptionType parameterDescription = null;
// Check if the parameter is an array
if (arraySize != null && !arraySize.isEmpty()) {
// Create an array type and set its attributes
ArrayDataTypeType arrayType = factory.createArrayDataTypeType();
String name = getNameByDataType(parameterName, dataType);
arrayType.setName(name + ARRAY);
arrayType.setArrayTypeRef(name + TYPE);
arrayType.setNumberOfDimensions(BigInteger.valueOf(ArrayVariable.getArrayIndexFromSize(arraySize).length));
// Set the parameter's array information
spaceSystem.getTelemetryMetaData().getParameterTypeSet().getStringParameterTypeOrEnumeratedParameterTypeOrIntegerParameterType().add(arrayType);
}
// Check if the parameter has a primitive data type
if (dataTypeHandler.isPrimitive(dataType)) {
// Get the XTCE data type corresponding to the primitive data type
XTCEDataType xtceDataType = getXTCEDataType(dataType);
// Check if the a corresponding XTCE data type exists
if (xtceDataType != null) {
// Set the parameter units
UnitSet unitSet = createUnitSet(units);
// Check if enumeration parameters are provided
if (enumeration != null && !enumeration.isEmpty()) {
// Create an enumeration type and enumeration list, and add any extra
// enumeration parameters as column data
EnumeratedParameterType enumType = factory.createParameterTypeSetTypeEnumeratedParameterType();
EnumerationList enumList = createEnumerationList(spaceSystem, enumeration);
// Set the integer encoding (the only encoding available for an enumeration)
// and the size in bits
IntegerDataEncodingType intEncodingType = factory.createIntegerDataEncodingType();
// Check if the parameter has a bit length
if (bitLength != null && !bitLength.isEmpty()) {
// Set the size in bits to the value supplied
intEncodingType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
} else // Not a bit-wise parameter
{
// Set the size in bits to the full size of the data type
intEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
}
// Check if the data type is an unsigned integer
if (dataTypeHandler.isUnsignedInt(dataType)) {
// Set the encoding type to indicate an unsigned integer
intEncodingType.setEncoding("unsigned");
}
// TODO ISSUE: THE CCSDS HEADER IS ALWAYS BIG ENDIAN - HOW AN THIS BE
// DETECTED? OR JUST ASSUME IT'S IGNORED BY THE USER FOR THAT CASE?
// Set the bit order
intEncodingType.setBitOrder(endianess == EndianType.BIG_ENDIAN ? "mostSignificantBitFirst" : "leastSignificantBitFirst");
enumType.setIntegerDataEncoding(intEncodingType);
// Set the enumeration list and units attributes
enumType.setEnumerationList(enumList);
enumType.setUnitSet(unitSet);
parameterDescription = enumType;
} else // Not an enumeration
{
switch(xtceDataType) {
case INTEGER:
// Create an integer parameter and set its attributes
IntegerParameterType integerType = factory.createParameterTypeSetTypeIntegerParameterType();
integerType.setUnitSet(unitSet);
IntegerDataEncodingType intEncodingType = factory.createIntegerDataEncodingType();
// Check if the parameter has a bit length
if (bitLength != null && !bitLength.isEmpty()) {
// Set the size in bits to the value supplied
integerType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
intEncodingType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
} else // Not a bit-wise parameter
{
// Set the encoding type to indicate an unsigned integer
integerType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
intEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
}
// Check if the data type is an unsigned integer
if (dataTypeHandler.isUnsignedInt(dataType)) {
// Set the encoding type to indicate an unsigned integer
integerType.setSigned(false);
intEncodingType.setEncoding("unsigned");
}
// Set the bit order
intEncodingType.setBitOrder(endianess == EndianType.BIG_ENDIAN ? "mostSignificantBitFirst" : "leastSignificantBitFirst");
integerType.setIntegerDataEncoding(intEncodingType);
// Check if a minimum or maximum value is specified
if ((minimum != null && !minimum.isEmpty()) || (maximum != null && !maximum.isEmpty())) {
IntegerRangeType range = factory.createIntegerRangeType();
// Check if a minimum value is specified
if (minimum != null && !minimum.isEmpty()) {
// Set the minimum value
range.setMinInclusive(minimum);
}
// Check if a maximum value is specified
if (maximum != null && !maximum.isEmpty()) {
// Set the maximum value
range.setMaxInclusive(maximum);
}
integerType.setValidRange(range);
}
parameterDescription = integerType;
break;
case FLOAT:
// Create a float parameter and set its attributes
FloatParameterType floatType = factory.createParameterTypeSetTypeFloatParameterType();
floatType.setUnitSet(unitSet);
FloatDataEncodingType floatEncodingType = factory.createFloatDataEncodingType();
floatEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
floatEncodingType.setEncoding("IEEE754_1985");
floatType.setFloatDataEncoding(floatEncodingType);
// Check if a minimum or maximum value is specified
if ((minimum != null && !minimum.isEmpty()) || (maximum != null && !maximum.isEmpty())) {
FloatRangeType range = factory.createFloatRangeType();
// Check if a minimum value is specified
if (minimum != null && !minimum.isEmpty()) {
// Set the minimum value
range.setMinInclusive(Double.valueOf(minimum));
}
// Check if a maximum value is specified
if (maximum != null && !maximum.isEmpty()) {
// Set the maximum value
range.setMaxInclusive(Double.valueOf(maximum));
}
floatType.setValidRange(range);
}
parameterDescription = floatType;
break;
case STRING:
// Create a string parameter and set its attributes
StringParameterType stringType = factory.createParameterTypeSetTypeStringParameterType();
stringType.setUnitSet(unitSet);
StringDataEncodingType stringEncodingType = factory.createStringDataEncodingType();
// Set the string's size in bits based on the number of characters in
// the string with each character occupying a single byte
IntegerValueType intValType = new IntegerValueType();
intValType.setFixedValue(String.valueOf(stringSize * 8));
SizeInBits sizeInBits = new SizeInBits();
sizeInBits.setFixed(intValType);
stringEncodingType.setSizeInBits(sizeInBits);
stringEncodingType.setEncoding("UTF-8");
stringType.setStringDataEncoding(stringEncodingType);
stringType.setCharacterWidth(BigInteger.valueOf(stringSize));
parameterDescription = stringType;
break;
}
}
}
} else // Structure data type
{
// Create an aggregate type for the structure
AggregateDataType aggregateType = factory.createAggregateDataType();
parameterName = dataType;
parameterDescription = aggregateType;
}
// Set the parameter type name
parameterDescription.setName(parameterName + TYPE);
// Check is a description exists
if (description != null && !description.isEmpty()) {
// Set the description attribute
parameterDescription.setLongDescription(description);
}
// Set the parameter's data type information
spaceSystem.getTelemetryMetaData().getParameterTypeSet().getStringParameterTypeOrEnumeratedParameterTypeOrIntegerParameterType().add(parameterDescription);
}
Also used :
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
StringParameterType(org.omg.space.xtce.ParameterTypeSetType.StringParameterType)
IntegerDataEncodingType(org.omg.space.xtce.IntegerDataEncodingType)
IntegerParameterType(org.omg.space.xtce.ParameterTypeSetType.IntegerParameterType)
IntegerRangeType(org.omg.space.xtce.IntegerRangeType)
SizeInBits(org.omg.space.xtce.StringDataEncodingType.SizeInBits)
IntegerValueType(org.omg.space.xtce.IntegerValueType)
NameDescriptionType(org.omg.space.xtce.NameDescriptionType)
ArrayDataTypeType(org.omg.space.xtce.ArrayDataTypeType)
FloatParameterType(org.omg.space.xtce.ParameterTypeSetType.FloatParameterType)
FloatDataEncodingType(org.omg.space.xtce.FloatDataEncodingType)
AggregateDataType(org.omg.space.xtce.AggregateDataType)
UnitSet(org.omg.space.xtce.BaseDataType.UnitSet)
StringDataEncodingType(org.omg.space.xtce.StringDataEncodingType)
EnumeratedParameterType(org.omg.space.xtce.ParameterTypeSetType.EnumeratedParameterType)
FloatRangeType(org.omg.space.xtce.FloatRangeType)
Example 2 with ArrayDataTypeType
use of org.omg.space.xtce.ArrayDataTypeType in project CCDD by nasa.
the class CcddXTCEHandler method setArgumentDataType.
/**
********************************************************************************************
* Set the command argument data type and set the specified attributes
*
* @param spaceSystem
* space system
*
* @param commandName
* command name
*
* @param argumentName
* command argument name; null to not specify
*
* @param dataType
* command argument data type; null to not specify
*
* @param arraySize
* command argument array size; null or blank if the argument isn't an array
*
* @param bitLength
* command argument bit length
*
* @param enumeration
* command argument enumeration in the format <enum label>|<enum value>[|...][,...];
* null to not specify
*
* @param units
* command argument units; null to not specify
*
* @param minimum
* minimum parameter value; null to not specify
*
* @param maximum
* maximum parameter value; null to not specify
*
* @param description
* command argument description ; null to not specify
*
* @param stringSize
* string size in bytes; ignored if the command argument does not have a string data
* type
*
* @return Command description of the type corresponding to the primitive data type with the
* specified attributes set
*
* @param uniqueID
* text used to uniquely identify data types with the same name; blank if the data
* type has no name conflict
********************************************************************************************
*/
private NameDescriptionType setArgumentDataType(SpaceSystemType spaceSystem, String commandName, String argumentName, String dataType, String arraySize, String bitLength, String enumeration, String units, String minimum, String maximum, String description, int stringSize, String uniqueID) {
BaseDataType commandDescription = null;
// Check if the argument is an array
if (arraySize != null && !arraySize.isEmpty()) {
// Create an array type and set its attributes
ArrayDataTypeType arrayType = factory.createArrayDataTypeType();
arrayType.setName(argumentName + ARRAY);
arrayType.setNumberOfDimensions(BigInteger.valueOf(ArrayVariable.getArrayIndexFromSize(arraySize).length));
arrayType.setArrayTypeRef(argumentName + TYPE);
// Set the argument's array information
spaceSystem.getCommandMetaData().getArgumentTypeSet().getStringArgumentTypeOrEnumeratedArgumentTypeOrIntegerArgumentType().add(arrayType);
}
// Get the XTCE data type corresponding to the primitive data type
XTCEDataType xtceDataType = getXTCEDataType(dataType);
// Check if the a corresponding XTCE data type exists
if (xtceDataType != null) {
UnitSet unitSet = null;
// Check if units is provided
if (units != null && !units.isEmpty()) {
// Set the command units
unitSet = createUnitSet(units);
}
// Check if enumeration parameters are provided
if (enumeration != null && !enumeration.isEmpty()) {
// Create an enumeration type and enumeration list, and add any extra enumeration
// parameters as column data
EnumeratedDataType enumType = factory.createEnumeratedDataType();
EnumerationList enumList = createEnumerationList(spaceSystem, enumeration);
// Set the integer encoding (the only encoding available for an enumeration) and
// the size in bits
IntegerDataEncodingType intEncodingType = factory.createIntegerDataEncodingType();
// Check if the parameter has a bit length
if (bitLength != null && !bitLength.isEmpty()) {
// Set the size in bits to the value supplied
intEncodingType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
} else // Not a bit-wise parameter
{
// Set the size in bits to the full size of the data type
intEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
}
// Set the enumeration list and units attributes
enumType.setEnumerationList(enumList);
enumType.setUnitSet(unitSet);
// Check if the data type is an unsigned integer
if (dataTypeHandler.isUnsignedInt(dataType)) {
// Set the encoding type to indicate an unsigned integer
intEncodingType.setEncoding("unsigned");
}
// Set the bit order
intEncodingType.setBitOrder(endianess == EndianType.BIG_ENDIAN ? "mostSignificantBitFirst" : "leastSignificantBitFirst");
enumType.setIntegerDataEncoding(intEncodingType);
commandDescription = enumType;
} else // This is not an enumerated command argument
{
switch(xtceDataType) {
case INTEGER:
// Create an integer command argument and set its attributes
IntegerArgumentType integerType = factory.createArgumentTypeSetTypeIntegerArgumentType();
IntegerDataEncodingType intEncodingType = factory.createIntegerDataEncodingType();
// Check if the parameter has a bit length
if (bitLength != null && !bitLength.isEmpty()) {
// Set the size in bits to the value supplied
integerType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
intEncodingType.setSizeInBits(BigInteger.valueOf(Integer.parseInt(bitLength)));
} else // Not a bit-wise parameter
{
// Set the size in bits to the full size of the data type
integerType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
intEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
}
// Check if the data type is an unsigned integer
if (dataTypeHandler.isUnsignedInt(dataType)) {
// Set the encoding type to indicate an unsigned integer
integerType.setSigned(false);
intEncodingType.setEncoding("unsigned");
}
// Set the bit order
intEncodingType.setBitOrder(endianess == EndianType.BIG_ENDIAN ? "mostSignificantBitFirst" : "leastSignificantBitFirst");
integerType.setIntegerDataEncoding(intEncodingType);
// Check if a minimum or maximum value is specified
if ((minimum != null && !minimum.isEmpty()) || (maximum != null && !maximum.isEmpty())) {
IntegerArgumentType.ValidRangeSet validRange = factory.createArgumentTypeSetTypeIntegerArgumentTypeValidRangeSet();
IntegerRangeType range = new IntegerRangeType();
// Check if a minimum value is specified
if (minimum != null && !minimum.isEmpty()) {
// Set the minimum value
range.setMinInclusive(minimum);
}
// Check if a maximum value is specified
if (maximum != null && !maximum.isEmpty()) {
// Set the maximum value
range.setMaxInclusive(maximum);
}
validRange.getValidRange().add(range);
integerType.setValidRangeSet(validRange);
}
commandDescription = integerType;
break;
case FLOAT:
// Create a float command argument and set its attributes
FloatArgumentType floatType = factory.createArgumentTypeSetTypeFloatArgumentType();
FloatDataEncodingType floatEncodingType = factory.createFloatDataEncodingType();
floatEncodingType.setSizeInBits(BigInteger.valueOf(dataTypeHandler.getSizeInBits(dataType)));
floatEncodingType.setEncoding("IEEE754_1985");
floatType.setFloatDataEncoding(floatEncodingType);
// Check if a minimum or maximum value is specified
if ((minimum != null && !minimum.isEmpty()) || (maximum != null && !maximum.isEmpty())) {
FloatArgumentType.ValidRangeSet validRange = factory.createArgumentTypeSetTypeFloatArgumentTypeValidRangeSet();
FloatRangeType range = new FloatRangeType();
// Check if a minimum value is specified
if (minimum != null && !minimum.isEmpty()) {
// Set the minimum value
range.setMinExclusive(Double.valueOf(minimum));
}
// Check if a maximum value is specified
if (maximum != null && !maximum.isEmpty()) {
// Set the maximum value
range.setMaxExclusive(Double.valueOf(maximum));
}
validRange.getValidRange().add(range);
floatType.setValidRangeSet(validRange);
}
commandDescription = floatType;
break;
case STRING:
// Create a string command argument and set its attributes
StringDataType stringType = factory.createStringDataType();
stringType.setCharacterWidth(BigInteger.valueOf(stringSize));
StringDataEncodingType stringEncodingType = factory.createStringDataEncodingType();
// Set the string's size in bits based on the number of characters in the
// string with each character occupying a single byte
IntegerValueType intValType = new IntegerValueType();
intValType.setFixedValue(String.valueOf(stringSize * 8));
SizeInBits sizeInBits = new SizeInBits();
sizeInBits.setFixed(intValType);
stringEncodingType.setSizeInBits(sizeInBits);
stringEncodingType.setEncoding("UTF-8");
stringType.setStringDataEncoding(stringEncodingType);
commandDescription = stringType;
break;
}
}
// Set the command name and argument name attributes
commandDescription.setName(argumentName + TYPE + uniqueID);
// Check is a description exists
if (description != null && !description.isEmpty()) {
// Set the command description attribute
commandDescription.setLongDescription(description);
}
}
return commandDescription;
}
Also used :
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
IntegerDataEncodingType(org.omg.space.xtce.IntegerDataEncodingType)
EnumeratedDataType(org.omg.space.xtce.EnumeratedDataType)
IntegerRangeType(org.omg.space.xtce.IntegerRangeType)
SizeInBits(org.omg.space.xtce.StringDataEncodingType.SizeInBits)
IntegerValueType(org.omg.space.xtce.IntegerValueType)
ArrayDataTypeType(org.omg.space.xtce.ArrayDataTypeType)
FloatArgumentType(org.omg.space.xtce.ArgumentTypeSetType.FloatArgumentType)
StringDataType(org.omg.space.xtce.StringDataType)
IntegerArgumentType(org.omg.space.xtce.ArgumentTypeSetType.IntegerArgumentType)
FloatDataEncodingType(org.omg.space.xtce.FloatDataEncodingType)
BaseDataType(org.omg.space.xtce.BaseDataType)
UnitSet(org.omg.space.xtce.BaseDataType.UnitSet)
StringDataEncodingType(org.omg.space.xtce.StringDataEncodingType)
FloatRangeType(org.omg.space.xtce.FloatRangeType)
Example 3 with ArrayDataTypeType
use of org.omg.space.xtce.ArrayDataTypeType in project CCDD by nasa.
the class CcddXTCEHandler method importStructureTable.
/**
********************************************************************************************
* Build a structure table from the specified telemetry metadata
*
* @param system
* space system
*
* @param tlmMetaData
* reference to the telemetry metadata from which to build the structure table
*
* @param table
* name table name, including the full system path
*
* @throws CCDDException
* If an input error is detected
********************************************************************************************
*/
private void importStructureTable(SpaceSystemType system, TelemetryMetaDataType tlmMetaData, String tableName) throws CCDDException {
// Create a table definition for this structure table. If the name space also includes a
// command metadata (which creates a command table) then ensure the two tables have
// different names
TableDefinition tableDefn = new TableDefinition(tableName + (system.getCommandMetaData() == null ? "" : "_tlm"), system.getLongDescription());
// Check if a description exists for this structure table
if (system.getLongDescription() != null && !system.getLongDescription().isEmpty()) {
// Store the table's description
tableDefn.setDescription(system.getLongDescription());
}
// Set the new structure table's table type name
tableDefn.setTypeName(structureTypeDefn.getName());
// Get the telemetry information
ParameterSetType parmSetType = tlmMetaData.getParameterSet();
ParameterTypeSetType parmTypeSetType = tlmMetaData.getParameterTypeSet();
// Check if the telemetry information exists
if (parmSetType != null && parmTypeSetType != null) {
// Get the references to the parameter set and parameter type set
List<Object> parmSet = parmSetType.getParameterOrParameterRef();
List<NameDescriptionType> parmTypeSet = parmTypeSetType.getStringParameterTypeOrEnumeratedParameterTypeOrIntegerParameterType();
// Step through each telemetry parameter
for (int parmIndex = 0; parmIndex < parmSet.size(); parmIndex++) {
// Get the reference to the parameter in the parameter set
Parameter parm = (Parameter) parmSet.get(parmIndex);
// Create a new row of data in the table definition to contain this
// structures's information. Initialize all columns to blanks except for the
// variable name
String[] newRow = new String[numStructureColumns];
Arrays.fill(newRow, null);
newRow[variableNameIndex] = parm.getName();
tableDefn.addData(newRow);
// name matches the parameter type reference from the parameter set
for (NameDescriptionType parmType : parmTypeSet) {
// parameter type set's name
if (parm.getParameterTypeRef().equals(parmType.getName())) {
String dataType = null;
String arraySize = null;
BigInteger bitLength = null;
long sizeInBytes = 0;
String enumeration = null;
String minimum = null;
String maximum = null;
UnitSet unitSet = null;
// Check if the parameter is an array data type
if (parmType instanceof ArrayDataTypeType) {
// The size of each array dimension is located in a container set.
// The array parameter reference containing the dimensions for the
// parameter matches the parameter name. Get the container set
// reference
ContainerSetType containerSet = tlmMetaData.getContainerSet();
// Check if the container set exists
if (containerSet != null) {
// Step through each sequence container in the container set
for (SequenceContainerType seqContainer : containerSet.getSequenceContainer()) {
// system
if (system.getName().equals(seqContainer.getName())) {
// Step through each entry in the sequence
for (SequenceEntryType entry : seqContainer.getEntryList().getParameterRefEntryOrParameterSegmentRefEntryOrContainerRefEntry()) {
// parameter reference matches the target parameter
if (entry instanceof ArrayParameterRefEntryType && parm.getName().equals(((ArrayParameterRefEntryType) entry).getParameterRef())) {
arraySize = "";
// Store the reference to the array parameter
// type
ArrayDataTypeType arrayType = (ArrayDataTypeType) parmType;
parmType = null;
// variable
for (Dimension dim : ((ArrayParameterRefEntryType) entry).getDimensionList().getDimension()) {
// Build the array size string
arraySize += String.valueOf(dim.getEndingIndex().getFixedValue()) + ",";
}
arraySize = CcddUtilities.removeTrailer(arraySize, ",");
// to locate this data type entry
for (NameDescriptionType type : parmTypeSet) {
// name
if (arrayType.getArrayTypeRef().equals(type.getName())) {
// Store the reference to the array
// parameter's data type and stop
// searching
parmType = type;
break;
}
}
}
}
break;
}
}
}
}
// locate the data type entry for the individual array members)
if (parmType != null) {
boolean isInteger = false;
boolean isUnsigned = false;
boolean isFloat = false;
boolean isString = false;
// Check if the parameter is an integer data type
if (parmType instanceof IntegerParameterType) {
// The 'sizeInBits' references are the integer size for
// non-bit-wise parameters, but equal the number of bits
// assigned to the parameter for a bit-wise parameter. It
// doens't appear that the size of the integer used to contain
// the parameter is stored. The assumption is made that the
// smallest integer required to store the bits is used.
// However, this can alter the originally intended bit-packing
// (e.g., a 3-bit and a 9-bit fit within a single 16-bit
// integer, but the code below assigns the first to an 8-bit
// integer and the second to a 16-bit integer)
IntegerParameterType itlm = (IntegerParameterType) parmType;
// Get the number of bits occupied by the parameter
bitLength = itlm.getSizeInBits();
// Get the parameter units reference
unitSet = itlm.getUnitSet();
// Check if integer encoding is set to 'unsigned'
if (itlm.getIntegerDataEncoding().getEncoding().equalsIgnoreCase("unsigned")) {
isUnsigned = true;
}
// Determine the smallest integer size that contains the number
// of bits occupied by the parameter
sizeInBytes = 8;
while (bitLength.longValue() > sizeInBytes) {
sizeInBytes *= 2;
}
sizeInBytes /= 8;
// Get the parameter range
IntegerRangeType range = itlm.getValidRange();
// Check if the parameter has a range
if (range != null) {
// Check if the minimum value exists
if (range.getMinInclusive() != null) {
// Store the minimum
minimum = range.getMinInclusive();
}
// Check if the maximum value exists
if (range.getMaxInclusive() != null) {
// Store the maximum
maximum = range.getMaxInclusive();
}
}
isInteger = true;
} else // Check if the parameter is a floating point data type
if (parmType instanceof FloatParameterType) {
// Get the float parameter attributes
FloatParameterType ftlm = (FloatParameterType) parmType;
sizeInBytes = ftlm.getSizeInBits().longValue() / 8;
unitSet = ftlm.getUnitSet();
// Get the parameter range
FloatRangeType range = ftlm.getValidRange();
// Check if the parameter has a range
if (range != null) {
// Check if the minimum value exists
if (range.getMinInclusive() != null) {
// Store the minimum
minimum = String.valueOf(range.getMinInclusive());
}
// Check if the maximum exists
if (range.getMaxInclusive() != null) {
// Store the maximum
maximum = String.valueOf(range.getMaxInclusive());
}
}
isFloat = true;
} else // Check if the parameter is a string data type
if (parmType instanceof StringParameterType) {
// Get the string parameter attributes
StringParameterType stlm = (StringParameterType) parmType;
sizeInBytes = stlm.getCharacterWidth().longValue();
unitSet = stlm.getUnitSet();
isString = true;
} else // Check if the parameter is an enumerated data type
if (parmType instanceof EnumeratedParameterType) {
// Get the enumeration parameters
EnumeratedParameterType etlm = (EnumeratedParameterType) parmType;
EnumerationList enumList = etlm.getEnumerationList();
// Check if any enumeration parameters are defined
if (enumList != null) {
// Step through each enumeration parameter
for (ValueEnumerationType enumType : enumList.getEnumeration()) {
// Check if this is the first parameter
if (enumeration == null) {
// Initialize the enumeration string
enumeration = "";
} else // Not the first parameter
{
// Add the separator for the enumerations
enumeration += ",";
}
// Begin building this enumeration
enumeration += enumType.getValue() + " | " + enumType.getLabel();
}
bitLength = etlm.getIntegerDataEncoding().getSizeInBits();
unitSet = etlm.getUnitSet();
// Check if integer encoding is set to 'unsigned'
if (etlm.getIntegerDataEncoding().getEncoding().equalsIgnoreCase("unsigned")) {
isUnsigned = true;
}
// Determine the smallest integer size that contains the
// number of bits occupied by the parameter
sizeInBytes = 8;
while (bitLength.longValue() > sizeInBytes) {
sizeInBytes *= 2;
}
sizeInBytes /= 8;
isInteger = true;
}
} else // structure reference
if (parmType instanceof AggregateDataType) {
// The aggregate type contains a member list of the parameters
// belonging to the referenced structure. Each list parameter
// has the path to the space system defining the structure;
// this path is used to get the structure data type
// Get the reference to the aggregate's member list
List<Member> memberList = ((AggregateDataType) parmType).getMemberList().getMember();
// Check if the member list exists
if (!memberList.isEmpty()) {
// Get the type reference of the structure's first
// parameter which is the path to its space system
dataType = memberList.get(0).getTypeRef();
// beginning '/' is stripped off
if (dataType.startsWith("/")) {
// Remove the initial '/'
dataType = dataType.substring(1);
}
// The variable name must be stripped from the space system
// path. Get the index of the beginning of the variable
// name
int end = dataType.lastIndexOf("/");
// Check if the beginning of the variable name was found
if (end != -1) {
// Strip off the variable name from the path
dataType = dataType.substring(0, end);
}
// Convert the path to a valid structure name, replacing
// invalid characters with underscores
dataType = convertPathToTableName(dataType);
}
}
// Check if the data type isn't a structure reference
if (dataType == null) {
// Get the name of the data type from the data type table that
// matches the base type and size of the parameter
dataType = getDataType(dataTypeHandler, sizeInBytes, isInteger, isUnsigned, isFloat, isString);
}
// Check if a data type exists
if (dataType != null) {
// Store the data type
tableDefn.getData().set(parmIndex * numStructureColumns + dataTypeIndex, dataType);
}
// Check if a array size exists
if (arraySize != null) {
// Store the array size
tableDefn.getData().set(parmIndex * numStructureColumns + arraySizeIndex, arraySize);
}
// Check if a bit length exists
if (bitLength != null && bitLength.longValue() != sizeInBytes) {
// Store the bit length
tableDefn.getData().set(parmIndex * numStructureColumns + bitLengthIndex, bitLength.toString());
}
// Check if a description exists
if (parmType.getLongDescription() != null) {
// Store the description
tableDefn.getData().set(parmIndex * numStructureColumns + descriptionIndex, parmType.getLongDescription());
}
// Check if a units exists and
if (unitSet != null) {
List<UnitType> unitType = unitSet.getUnit();
// Check if the units exist
if (!unitType.isEmpty()) {
// Store the units for this variable
tableDefn.getData().set(parmIndex * numStructureColumns + unitsIndex, unitType.get(0).getContent());
}
}
// Check if an enumeration exists
if (enumeration != null) {
// Store the enumeration parameters. This accounts only for the
// first enumeration for a variable
tableDefn.getData().set(parmIndex * numStructureColumns + enumerationIndex, enumeration);
}
// Check if a minimum value exists
if (minimum != null) {
// Store the minimum value
tableDefn.getData().set(parmIndex * numStructureColumns + minimumIndex, minimum);
}
// Check if a maximum value exists
if (maximum != null) {
// Store the maximum value
tableDefn.getData().set(parmIndex * numStructureColumns + maximumIndex, maximum);
}
}
break;
}
}
}
ContainerSetType containerSet;
// Check if the application ID data field name and the container set exist
if ((containerSet = tlmMetaData.getContainerSet()) != null) {
// Step through each sequence container in the container set
for (SequenceContainerType seqContainer : containerSet.getSequenceContainer()) {
// Check if this is the sequence container for the target system
if (system.getName().equals(seqContainer.getName())) {
BaseContainer baseContainer;
RestrictionCriteria restrictionCriteria;
ComparisonList comparisonList;
// Check if the comparison list exists
if (((baseContainer = seqContainer.getBaseContainer()) != null) && ((restrictionCriteria = baseContainer.getRestrictionCriteria()) != null) && ((comparisonList = restrictionCriteria.getComparisonList()) != null)) {
// Step through each item in the comparison list
for (ComparisonType comparison : comparisonList.getComparison()) {
// application ID name
if (comparison.getParameterRef().equals(ccsdsAppID)) {
// Create a data field for the table containing the application
// ID. Once a match is found the search is discontinued
tableDefn.addDataField(new String[] { tableName, comparison.getParameterRef(), "Message ID", String.valueOf(comparison.getValue().length()), InputDataType.MESSAGE_ID.getInputName(), String.valueOf(false), ApplicabilityType.ROOT_ONLY.getApplicabilityName(), comparison.getValue() });
break;
}
}
}
break;
}
}
}
}
// Add the structure table definition to the list
tableDefinitions.add(tableDefn);
}
Also used :
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
ValueEnumerationType(org.omg.space.xtce.ValueEnumerationType)
SequenceContainerType(org.omg.space.xtce.SequenceContainerType)
ComparisonType(org.omg.space.xtce.ComparisonType)
StringParameterType(org.omg.space.xtce.ParameterTypeSetType.StringParameterType)
IntegerParameterType(org.omg.space.xtce.ParameterTypeSetType.IntegerParameterType)
IntegerRangeType(org.omg.space.xtce.IntegerRangeType)
RestrictionCriteria(org.omg.space.xtce.SequenceContainerType.BaseContainer.RestrictionCriteria)
SequenceEntryType(org.omg.space.xtce.SequenceEntryType)
NameDescriptionType(org.omg.space.xtce.NameDescriptionType)
BaseContainer(org.omg.space.xtce.SequenceContainerType.BaseContainer)
FloatParameterType(org.omg.space.xtce.ParameterTypeSetType.FloatParameterType)
UnitType(org.omg.space.xtce.UnitType)
ArrayParameterRefEntryType(org.omg.space.xtce.ArrayParameterRefEntryType)
TableDefinition(CCDD.CcddClassesDataTable.TableDefinition)
ParameterTypeSetType(org.omg.space.xtce.ParameterTypeSetType)
ComparisonList(org.omg.space.xtce.MatchCriteriaType.ComparisonList)
Member(org.omg.space.xtce.AggregateDataType.MemberList.Member)
ParameterSetType(org.omg.space.xtce.ParameterSetType)
Dimension(org.omg.space.xtce.ArrayParameterRefEntryType.DimensionList.Dimension)
ArrayDataTypeType(org.omg.space.xtce.ArrayDataTypeType)
ContainerSetType(org.omg.space.xtce.ContainerSetType)
AggregateDataType(org.omg.space.xtce.AggregateDataType)
Parameter(org.omg.space.xtce.ParameterSetType.Parameter)
BigInteger(java.math.BigInteger)
UnitSet(org.omg.space.xtce.BaseDataType.UnitSet)
FloatRangeType(org.omg.space.xtce.FloatRangeType)
EnumeratedParameterType(org.omg.space.xtce.ParameterTypeSetType.EnumeratedParameterType)
Example 4 with ArrayDataTypeType
use of org.omg.space.xtce.ArrayDataTypeType in project CCDD by nasa.
the class CcddXTCEHandler method importCommandTable.
/**
********************************************************************************************
* Build a command table from the specified command metadata
*
* @param system
* space system
*
* @param cmdMetaData
* reference to the command metadata from which to build the command table
*
* @param table
* name table name, including the full system path
*
* @throws CCDDException
* If an input error is detected
********************************************************************************************
*/
private void importCommandTable(SpaceSystemType system, CommandMetaDataType cmdMetaData, String tableName) throws CCDDException {
// Create a table definition for this command table. If the name space also includes a
// telemetry metadata (which creates a structure table) then ensure the two tables have
// different names
TableDefinition tableDefn = new TableDefinition(tableName + (system.getTelemetryMetaData() == null ? "" : "_cmd"), system.getLongDescription());
// Check if a description exists for this command table
if (system.getLongDescription() != null && !system.getLongDescription().isEmpty()) {
// Store the table's description
tableDefn.setDescription(system.getLongDescription());
}
// Set the new command table's table type name
tableDefn.setTypeName(commandTypeDefn.getName());
// Check if the description column belongs to a command argument
if (commandArguments.size() != 0 && cmdDescriptionIndex > commandArguments.get(0).getName()) {
// Reset the command description index to indicate no description exists
cmdDescriptionIndex = -1;
}
// Get the command set information
MetaCommandSet metaCmdSet = cmdMetaData.getMetaCommandSet();
// Check if the command set information exists
if (metaCmdSet != null) {
// Get the command argument information
ArgumentTypeSetType argTypeSetType = cmdMetaData.getArgumentTypeSet();
List<NameDescriptionType> argTypeSet = null;
// Check if there are any arguments for this command
if (argTypeSetType != null) {
// Get the list of this command's argument data types
argTypeSet = argTypeSetType.getStringArgumentTypeOrEnumeratedArgumentTypeOrIntegerArgumentType();
}
// Step through each command set
for (Object cmd : metaCmdSet.getMetaCommandOrMetaCommandRefOrBlockMetaCommand()) {
// Check if the command represents a meta command type (all of these should)
if (cmd instanceof MetaCommandType) {
// Get the command type as a meta command type to shorten subsequent calls
MetaCommandType metaCmd = (MetaCommandType) cmd;
// Create a new row of data in the table definition to contain this command's
// information. Initialize all columns to blanks except for the command name
String[] newRow = new String[numCommandColumns];
Arrays.fill(newRow, null);
newRow[commandNameIndex] = metaCmd.getName();
// Get the base meta-command reference
BaseMetaCommand baseMetaCmd = metaCmd.getBaseMetaCommand();
// Check if the base meta-command exists
if (baseMetaCmd != null) {
// Step through each argument assignment
for (ArgumentAssignment argAssn : baseMetaCmd.getArgumentAssignmentList().getArgumentAssignment()) {
// column name
if (argAssn.getArgumentName().equals(ccsdsAppID)) {
boolean isExists = false;
// Step through the data fields already added to this table
for (String[] fieldInfo : tableDefn.getDataFields()) {
// subsequent ones are ignored to prevent duplicates
if (fieldInfo[FieldsColumn.FIELD_NAME.ordinal()].equals(argAssn.getArgumentName())) {
// Set the flag indicating the field already exists and
// stop searching
isExists = true;
break;
}
}
// Check if the application ID data field doesn't exist
if (!isExists) {
// Create a data field for the table containing the application
// ID and stop searching
tableDefn.addDataField(new String[] { tableName, argAssn.getArgumentName(), "Message ID", String.valueOf(argAssn.getArgumentValue().length()), InputDataType.MESSAGE_ID.getInputName(), String.valueOf(false), ApplicabilityType.ALL.getApplicabilityName(), argAssn.getArgumentValue() });
}
} else // argument column name
if (argAssn.getArgumentName().equals(ccsdsFuncCode)) {
// Store the command function code and stop searching
newRow[commandCodeIndex] = argAssn.getArgumentValue();
break;
}
}
}
// exists in the table type definition
if (metaCmd.getLongDescription() != null && cmdDescriptionIndex != -1) {
// Store the command description in the row's description column
newRow[cmdDescriptionIndex] = metaCmd.getLongDescription();
}
// Check if the command has any arguments
if (metaCmd.getArgumentList() != null && argTypeSet != null) {
int cmdArgIndex = 0;
CommandContainerType cmdContainer = metaCmd.getCommandContainer();
// Step through each of the command's arguments
for (Argument argList : metaCmd.getArgumentList().getArgument()) {
// Step through each command argument type
for (NameDescriptionType argType : argTypeSet) {
// between the two)
if (argList.getArgumentTypeRef().equals(argType.getName())) {
boolean isInteger = false;
boolean isUnsigned = false;
boolean isFloat = false;
boolean isString = false;
String dataType = null;
String arraySize = null;
BigInteger bitLength = null;
long sizeInBytes = 0;
String enumeration = null;
String description = null;
UnitSet unitSet = null;
String units = null;
String minimum = null;
String maximum = null;
// Check if the argument is an array data type
if (argType instanceof ArrayDataTypeType && metaCmd != null && cmdContainer != null) {
// set
for (JAXBElement<? extends SequenceEntryType> seqEntry : cmdContainer.getEntryList().getParameterRefEntryOrParameterSegmentRefEntryOrContainerRefEntry()) {
// reference matches the target parameter
if (seqEntry.getValue() instanceof ArrayParameterRefEntryType && argList.getName().equals(((ArrayParameterRefEntryType) seqEntry.getValue()).getParameterRef())) {
arraySize = "";
// Store the reference to the array parameter type
ArrayDataTypeType arrayType = (ArrayDataTypeType) argType;
argType = null;
// the array variable
for (Dimension dim : ((ArrayParameterRefEntryType) seqEntry.getValue()).getDimensionList().getDimension()) {
// Build the array size string
arraySize += String.valueOf(dim.getEndingIndex().getFixedValue()) + ",";
}
arraySize = CcddUtilities.removeTrailer(arraySize, ",");
// data type entry
for (NameDescriptionType type : argTypeSet) {
// reference matches the data type name
if (arrayType.getArrayTypeRef().equals(type.getName())) {
// Store the reference to the array
// parameter's data type and stop searching
argType = type;
break;
}
}
break;
}
}
}
// individual array members)
if (argType != null) {
// Check if the argument is an integer data type
if (argType instanceof IntegerArgumentType) {
IntegerArgumentType icmd = (IntegerArgumentType) argType;
// Get the number of bits occupied by the argument
bitLength = icmd.getSizeInBits();
// Get the argument units reference
unitSet = icmd.getUnitSet();
// Check if integer encoding is set to 'unsigned'
if (icmd.getIntegerDataEncoding().getEncoding().equalsIgnoreCase("unsigned")) {
isUnsigned = true;
}
// Determine the smallest integer size that contains
// the number of bits occupied by the argument
sizeInBytes = 8;
while (bitLength.longValue() > sizeInBytes) {
sizeInBytes *= 2;
}
sizeInBytes /= 8;
// Get the argument alarm
IntegerArgumentType.ValidRangeSet alarmType = icmd.getValidRangeSet();
// Check if the argument has an alarm
if (alarmType != null) {
// Get the alarm range
List<IntegerRangeType> alarmRange = alarmType.getValidRange();
// Check if the alarm range exists
if (alarmRange != null) {
// Store the minimum alarm value
minimum = alarmRange.get(0).getMinInclusive();
// Store the maximum alarm value
maximum = alarmRange.get(0).getMaxInclusive();
}
}
isInteger = true;
} else // Check if the argument is a floating point data type
if (argType instanceof FloatArgumentType) {
// Get the float argument attributes
FloatArgumentType fcmd = (FloatArgumentType) argType;
sizeInBytes = fcmd.getSizeInBits().longValue() / 8;
unitSet = fcmd.getUnitSet();
// Get the argument alarm
FloatArgumentType.ValidRangeSet alarmType = fcmd.getValidRangeSet();
// Check if the argument has an alarm
if (alarmType != null) {
// Get the alarm range
List<FloatRangeType> alarmRange = alarmType.getValidRange();
// Check if the alarm range exists
if (alarmRange != null) {
// Get the minimum value
Double min = alarmRange.get(0).getMinInclusive();
// Check if a minimum value exists
if (min != null) {
// Get the minimum alarm value
minimum = String.valueOf(min);
}
// Get the maximum value
Double max = alarmRange.get(0).getMaxInclusive();
// Check if a maximum value exists
if (max != null) {
// Get the maximum alarm value
maximum = String.valueOf(max);
}
}
}
isFloat = true;
} else // Check if the argument is a string data type
if (argType instanceof StringDataType) {
// Get the string argument attributes
StringDataType scmd = (StringDataType) argType;
sizeInBytes = scmd.getCharacterWidth().longValue();
unitSet = scmd.getUnitSet();
isString = true;
} else // Check if the argument is an enumerated data type
if (argType instanceof EnumeratedDataType) {
EnumeratedDataType ecmd = (EnumeratedDataType) argType;
EnumerationList enumList = ecmd.getEnumerationList();
// Check if any enumeration parameters are defined
if (enumList != null) {
// Step through each enumeration parameter
for (ValueEnumerationType enumType : enumList.getEnumeration()) {
// Check if this is the first parameter
if (enumeration == null) {
// Initialize the enumeration string
enumeration = "";
} else // Not the first parameter
{
// Add the separator for the
// enumerations
enumeration += ", ";
}
// Begin building this enumeration
enumeration += enumType.getValue() + " | " + enumType.getLabel();
}
bitLength = ecmd.getIntegerDataEncoding().getSizeInBits();
unitSet = ecmd.getUnitSet();
// 'unsigned'
if (ecmd.getIntegerDataEncoding().getEncoding().equalsIgnoreCase("unsigned")) {
isUnsigned = true;
}
// Determine the smallest integer size that
// contains the number of bits occupied by the
// argument
sizeInBytes = 8;
while (bitLength.longValue() > sizeInBytes) {
sizeInBytes *= 2;
}
sizeInBytes /= 8;
isInteger = true;
}
}
// Get the name of the data type from the data type table
// that matches the base type and size of the parameter
dataType = getDataType(dataTypeHandler, sizeInBytes, isInteger, isUnsigned, isFloat, isString);
// Check if the description exists
if (argType.getLongDescription() != null) {
// Store the description
description = argType.getLongDescription();
}
// Check if the units exists
if (unitSet != null) {
List<UnitType> unitType = unitSet.getUnit();
// Check if the units is set
if (!unitType.isEmpty()) {
// Store the units
units = unitType.get(0).getContent();
}
}
// dictated by the table type definition
if (cmdArgIndex < commandArguments.size()) {
// Get the command argument reference
AssociatedColumns acmdArg = commandArguments.get(cmdArgIndex);
// Check if the command argument name is present
if (acmdArg.getName() != -1) {
// Store the command argument name
newRow[acmdArg.getName()] = argList.getName();
}
// Check if the command argument data type is present
if (acmdArg.getDataType() != -1 && dataType != null) {
// Store the command argument data type
newRow[acmdArg.getDataType()] = dataType;
}
// Check if the command argument array size is present
if (acmdArg.getArraySize() != -1 && arraySize != null) {
// Store the command argument array size
newRow[acmdArg.getArraySize()] = arraySize;
}
// Check if the command argument bit length is present
if (acmdArg.getBitLength() != -1 && bitLength != null) {
// Store the command argument bit length
newRow[acmdArg.getBitLength()] = bitLength.toString();
}
// Check if the command argument enumeration is present
if (acmdArg.getEnumeration() != -1 && enumeration != null) {
// Store the command argument enumeration
newRow[acmdArg.getEnumeration()] = enumeration;
}
// Check if the command argument description is present
if (acmdArg.getDescription() != -1 && description != null) {
// Store the command argument description
newRow[acmdArg.getDescription()] = description;
}
// Check if the command argument units is present
if (acmdArg.getUnits() != -1 && units != null) {
// Store the command argument units
newRow[acmdArg.getUnits()] = units;
}
// Check if the command argument minimum is present
if (acmdArg.getMinimum() != -1 && minimum != null) {
// Store the command argument minimum
newRow[acmdArg.getMinimum()] = minimum;
}
// Check if the command argument maximum is present
if (acmdArg.getMaximum() != -1 && maximum != null) {
// Store the command argument maximum
newRow[acmdArg.getMaximum()] = maximum;
}
}
}
// Increment the argument index
cmdArgIndex++;
break;
}
}
}
}
// Add the new row to the table definition
tableDefn.addData(newRow);
}
}
}
// Add the command table definition to the list
tableDefinitions.add(tableDefn);
}
Also used :
MetaCommandSet(org.omg.space.xtce.CommandMetaDataType.MetaCommandSet)
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
ValueEnumerationType(org.omg.space.xtce.ValueEnumerationType)
ArgumentTypeSetType(org.omg.space.xtce.ArgumentTypeSetType)
Argument(org.omg.space.xtce.MetaCommandType.ArgumentList.Argument)
IntegerRangeType(org.omg.space.xtce.IntegerRangeType)
CommandContainerType(org.omg.space.xtce.CommandContainerType)
NameDescriptionType(org.omg.space.xtce.NameDescriptionType)
StringDataType(org.omg.space.xtce.StringDataType)
BaseMetaCommand(org.omg.space.xtce.MetaCommandType.BaseMetaCommand)
UnitType(org.omg.space.xtce.UnitType)
ArrayParameterRefEntryType(org.omg.space.xtce.ArrayParameterRefEntryType)
TableDefinition(CCDD.CcddClassesDataTable.TableDefinition)
MemberList(org.omg.space.xtce.AggregateDataType.MemberList)
ArgumentList(org.omg.space.xtce.MetaCommandType.ArgumentList)
ArgumentAssignmentList(org.omg.space.xtce.MetaCommandType.BaseMetaCommand.ArgumentAssignmentList)
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
List(java.util.List)
DimensionList(org.omg.space.xtce.ArrayParameterRefEntryType.DimensionList)
ComparisonList(org.omg.space.xtce.MatchCriteriaType.ComparisonList)
ArrayList(java.util.ArrayList)
EnumeratedDataType(org.omg.space.xtce.EnumeratedDataType)
Dimension(org.omg.space.xtce.ArrayParameterRefEntryType.DimensionList.Dimension)
ArrayDataTypeType(org.omg.space.xtce.ArrayDataTypeType)
ArgumentAssignment(org.omg.space.xtce.MetaCommandType.BaseMetaCommand.ArgumentAssignmentList.ArgumentAssignment)
FloatArgumentType(org.omg.space.xtce.ArgumentTypeSetType.FloatArgumentType)
IntegerArgumentType(org.omg.space.xtce.ArgumentTypeSetType.IntegerArgumentType)
AssociatedColumns(CCDD.CcddClassesDataTable.AssociatedColumns)
BigInteger(java.math.BigInteger)
UnitSet(org.omg.space.xtce.BaseDataType.UnitSet)
MetaCommandType(org.omg.space.xtce.MetaCommandType)
Aggregations
ArrayDataTypeType (org.omg.space.xtce.ArrayDataTypeType)4
UnitSet (org.omg.space.xtce.BaseDataType.UnitSet)4
EnumerationList (org.omg.space.xtce.EnumeratedDataType.EnumerationList)4
IntegerRangeType (org.omg.space.xtce.IntegerRangeType)4
FloatRangeType (org.omg.space.xtce.FloatRangeType)3
NameDescriptionType (org.omg.space.xtce.NameDescriptionType)3
TableDefinition (CCDD.CcddClassesDataTable.TableDefinition)2
BigInteger (java.math.BigInteger)2
AggregateDataType (org.omg.space.xtce.AggregateDataType)2
FloatArgumentType (org.omg.space.xtce.ArgumentTypeSetType.FloatArgumentType)2
IntegerArgumentType (org.omg.space.xtce.ArgumentTypeSetType.IntegerArgumentType)2
ArrayParameterRefEntryType (org.omg.space.xtce.ArrayParameterRefEntryType)2
Dimension (org.omg.space.xtce.ArrayParameterRefEntryType.DimensionList.Dimension)2
EnumeratedDataType (org.omg.space.xtce.EnumeratedDataType)2
FloatDataEncodingType (org.omg.space.xtce.FloatDataEncodingType)2
IntegerDataEncodingType (org.omg.space.xtce.IntegerDataEncodingType)2
IntegerValueType (org.omg.space.xtce.IntegerValueType)2
ComparisonList (org.omg.space.xtce.MatchCriteriaType.ComparisonList)2
StringDataType (org.omg.space.xtce.StringDataType)2
UnitType (org.omg.space.xtce.UnitType)2
