Example 1 with ValueEnumerationType
use of org.omg.space.xtce.ValueEnumerationType in project CCDD by nasa.
the class CcddXTCEHandler method createEnumerationList.
/**
********************************************************************************************
* Build an enumeration list from the supplied enumeration string
*
* @param spaceSystem
* space system
*
* @param enumeration
* enumeration in the format <enum value><enum value separator><enum label>[<enum
* value separator>...][<enum pair separator>...]
*
* @return Enumeration list for the supplied enumeration string
********************************************************************************************
*/
private EnumerationList createEnumerationList(SpaceSystemType spaceSystem, String enumeration) {
EnumerationList enumList = factory.createEnumeratedDataTypeEnumerationList();
try {
// Get the character that separates the enumeration value from the associated label
String enumValSep = CcddUtilities.getEnumeratedValueSeparator(enumeration);
// Check if the value separator couldn't be located
if (enumValSep == null) {
throw new CCDDException("initial non-negative integer or " + "separator character between " + "enumeration value and text missing");
}
// Get the character that separates the enumerated pairs
String enumPairSep = CcddUtilities.getEnumerationPairSeparator(enumeration, enumValSep);
// Check if the enumerated pair separator couldn't be located
if (enumPairSep == null) {
throw new CCDDException("separator character between enumerated pairs missing");
}
// Divide the enumeration string into the separate enumeration definitions
String[] enumDefn = enumeration.split(Pattern.quote(enumPairSep));
// Step through each enumeration definition
for (int index = 0; index < enumDefn.length; index++) {
// Split the enumeration definition into the name and label components
String[] enumParts = enumDefn[index].split(Pattern.quote(enumValSep), 2);
// Create a new enumeration value type and add the enumerated name and value to the
// enumeration list
ValueEnumerationType valueEnum = factory.createValueEnumerationType();
valueEnum.setLabel(enumParts[1].trim());
valueEnum.setValue(BigInteger.valueOf(Integer.valueOf(enumParts[0].trim())));
enumList.getEnumeration().add(valueEnum);
}
} catch (CCDDException ce) {
// Inform the user that the enumeration format is invalid
new CcddDialogHandler().showMessageDialog(parent, "<html><b>Enumeration '" + enumeration + "' format invalid in table '" + spaceSystem.getName() + "'; " + ce.getMessage(), "Enumeration Error", JOptionPane.WARNING_MESSAGE, DialogOption.OK_OPTION);
}
return enumList;
}
Also used :
EnumerationList(org.omg.space.xtce.EnumeratedDataType.EnumerationList)
ValueEnumerationType(org.omg.space.xtce.ValueEnumerationType)
CCDDException(CCDD.CcddClassesDataTable.CCDDException)
Example 2 with ValueEnumerationType
use of org.omg.space.xtce.ValueEnumerationType 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 3 with ValueEnumerationType
use of org.omg.space.xtce.ValueEnumerationType 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
EnumerationList (org.omg.space.xtce.EnumeratedDataType.EnumerationList)3
ValueEnumerationType (org.omg.space.xtce.ValueEnumerationType)3
TableDefinition (CCDD.CcddClassesDataTable.TableDefinition)2
BigInteger (java.math.BigInteger)2
ArrayDataTypeType (org.omg.space.xtce.ArrayDataTypeType)2
ArrayParameterRefEntryType (org.omg.space.xtce.ArrayParameterRefEntryType)2
Dimension (org.omg.space.xtce.ArrayParameterRefEntryType.DimensionList.Dimension)2
UnitSet (org.omg.space.xtce.BaseDataType.UnitSet)2
IntegerRangeType (org.omg.space.xtce.IntegerRangeType)2
ComparisonList (org.omg.space.xtce.MatchCriteriaType.ComparisonList)2
NameDescriptionType (org.omg.space.xtce.NameDescriptionType)2
UnitType (org.omg.space.xtce.UnitType)2
AssociatedColumns (CCDD.CcddClassesDataTable.AssociatedColumns)1
CCDDException (CCDD.CcddClassesDataTable.CCDDException)1
ArrayList (java.util.ArrayList)1
List (java.util.List)1
AggregateDataType (org.omg.space.xtce.AggregateDataType)1
MemberList (org.omg.space.xtce.AggregateDataType.MemberList)1
Member (org.omg.space.xtce.AggregateDataType.MemberList.Member)1
ArgumentTypeSetType (org.omg.space.xtce.ArgumentTypeSetType)1
