Search in sources :

Example 1 with EnumerationList

use of org.omg.space.xtce.EnumeratedDataType.EnumerationList 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 EnumerationList

use of org.omg.space.xtce.EnumeratedDataType.EnumerationList 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 3 with EnumerationList

use of org.omg.space.xtce.EnumeratedDataType.EnumerationList 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 4 with EnumerationList

use of org.omg.space.xtce.EnumeratedDataType.EnumerationList 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 5 with EnumerationList

use of org.omg.space.xtce.EnumeratedDataType.EnumerationList 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)5 ArrayDataTypeType (org.omg.space.xtce.ArrayDataTypeType)4 UnitSet (org.omg.space.xtce.BaseDataType.UnitSet)4 IntegerRangeType (org.omg.space.xtce.IntegerRangeType)4 FloatRangeType (org.omg.space.xtce.FloatRangeType)3 NameDescriptionType (org.omg.space.xtce.NameDescriptionType)3 ValueEnumerationType (org.omg.space.xtce.ValueEnumerationType)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