Examples with ArrayDataType org.ccsds.schema.sois.seds.ArrayDataType used on opensource projects

Example 1 with ArrayDataType

use of org.ccsds.schema.sois.seds.ArrayDataType in project CCDD by nasa.

the class CcddEDSHandler method importCommandTable.

/**
 ********************************************************************************************
 * Build a command table from the specified command metadata
 *
 * @param namespace
 *            name space
 *
 * @param commandSet
 *            reference to the command set from which to build the command table
 *
 * @param table
 *            name table name, including the full system path
 *
 * @param hasParameter
 *            true if the name space also has a parameter set
 *
 * @throws CCDDException
 *             If an input error is detected
 ********************************************************************************************
 */
private void importCommandTable(NamespaceType namespace, List<InterfaceCommandType> commandSet, String tableName, boolean hasParameter) throws CCDDException {
    // Create a table definition for this command table. If the name space also includes a
    // parameter set (which creates a structure table) then ensure the two tables have
    // different names
    TableDefinition tableDefn = new TableDefinition(tableName + (hasParameter ? "_cmd" : ""), namespace.getLongDescription());
    // Check if a description exists for this command table
    if (namespace.getLongDescription() != null && !namespace.getLongDescription().isEmpty()) {
        // Store the table's description
        tableDefn.setDescription(namespace.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;
    }
    // Step through each command
    for (InterfaceCommandType cmdType : commandSet) {
        // 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[commandTypeDefn.getColumnCountVisible()];
        Arrays.fill(newRow, null);
        newRow[commandNameIndex] = cmdType.getName();
        // table type definition
        if (cmdType.getLongDescription() != null && cmdDescriptionIndex != -1) {
            // Store the command description in the row's description
            // column
            newRow[cmdDescriptionIndex] = cmdType.getLongDescription();
        }
        int cmdArgIndex = 0;
        // Step through each of the command's arguments
        for (CommandArgumentType argList : cmdType.getArgument()) {
            // type
            if (namespace.getDataTypeSet() != null && commandNameIndex != -1) {
                // Step through each data type set
                for (RootDataType argType : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
                    // list (by matching the command and argument names between the two)
                    if (argList.getType().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;
                        Unit units = null;
                        String minimum = null;
                        String maximum = null;
                        // Check if the argument is an array data type
                        if (argType instanceof ArrayDataType) {
                            arraySize = "";
                            // Store the reference to the array parameter type
                            ArrayDataType arrayType = (ArrayDataType) argType;
                            argType = null;
                            // Step through each dimension for the array variable
                            for (DimensionSizeType dim : arrayType.getDimensionList().getDimension()) {
                                // Build the array size string
                                arraySize += String.valueOf(dim.getSize().longValue()) + ",";
                            }
                            arraySize = CcddUtilities.removeTrailer(arraySize, ",");
                            // type entry Step through each data type set
                            for (RootDataType type : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
                                // the data type name
                                if (arrayType.getDataTypeRef().equals(type.getName())) {
                                    // Store the reference to the array parameter's data type
                                    // and stop searching
                                    argType = type;
                                    break;
                                }
                            }
                        }
                        // locate the data type entry for the individual array members)
                        if (argType != null) {
                            // Check if the argument is an integer data type
                            if (argType instanceof IntegerDataType) {
                                IntegerDataType icmd = (IntegerDataType) argType;
                                // Get the number of bits occupied by the argument
                                bitLength = icmd.getIntegerDataEncoding().getSizeInBits();
                                // Check if units exist for this argument
                                if (icmd.getSemantics() != null && icmd.getSemantics().getUnit() != null) {
                                    // Get the argument units reference
                                    units = icmd.getSemantics().getUnit();
                                }
                                // Check if integer encoding is set to 'unsigned'
                                if (icmd.getIntegerDataEncoding().getEncoding() == IntegerEncodingType.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 range
                                IntegerDataTypeRangeType range = icmd.getRange();
                                // Check if the argument has a range
                                if (range != null && range.getMinMaxRange() != null) {
                                    MinMaxRangeType minMax = range.getMinMaxRange();
                                    // Check if the argument has a minimum value
                                    if (minMax.getMin() != null) {
                                        // Store the minimum value
                                        minimum = minMax.getMin().toString();
                                    }
                                    // Check if the argument has a maximum value
                                    if (minMax.getMax() != null) {
                                        // Store the maximum value
                                        maximum = minMax.getMax().toString();
                                    }
                                }
                                isInteger = true;
                            } else // Check if the argument is a floating point data type
                            if (argType instanceof FloatDataType) {
                                // Get the float argument attributes
                                FloatDataType fcmd = (FloatDataType) argType;
                                // Check if units exist for this argument
                                if (fcmd.getSemantics() != null && fcmd.getSemantics().getUnit() != null) {
                                    // Get the argument units reference
                                    units = fcmd.getSemantics().getUnit();
                                }
                                switch(fcmd.getFloatDataEncoding().getEncodingAndPrecision()) {
                                    case IEEE_754_2008_SINGLE:
                                        sizeInBytes = 4;
                                        break;
                                    case IEEE_754_2008_DOUBLE:
                                        sizeInBytes = 8;
                                        break;
                                    case IEEE_754_2008_QUAD:
                                        sizeInBytes = 16;
                                        break;
                                    default:
                                        break;
                                }
                                // Get the argument range
                                FloatDataTypeRangeType range = fcmd.getRange();
                                // Check if the argument has a range
                                if (range != null && range.getMinMaxRange() != null) {
                                    MinMaxRangeType minMax = range.getMinMaxRange();
                                    // Check if the argument has a minimum value
                                    if (minMax.getMin() != null) {
                                        // Store the minimum value
                                        minimum = minMax.getMin().toString();
                                    }
                                    // Check if the argument has a maximum value
                                    if (minMax.getMax() != null) {
                                        // Store the maximum value
                                        maximum = minMax.getMax().toString();
                                    }
                                }
                                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.getLength().longValue();
                                // Check if units exist for this argument
                                if (scmd.getSemantics() != null && scmd.getSemantics().getUnit() != null) {
                                    // Get the argument units reference
                                    units = scmd.getSemantics().getUnit();
                                }
                                isString = true;
                            } else // Check if the argument is an enumerated data type
                            if (argType instanceof EnumeratedDataType) {
                                EnumeratedDataType ecmd = (EnumeratedDataType) argType;
                                EnumerationListType 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();
                                    // Check if units exist for this argument
                                    if (ecmd.getSemantics() != null && ecmd.getSemantics().getUnit() != null) {
                                        // Get the argument units reference
                                        units = ecmd.getSemantics().getUnit();
                                    }
                                    // Check if integer encoding is set to 'unsigned'
                                    if (ecmd.getIntegerDataEncoding().getEncoding() == IntegerEncodingType.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;
                                }
                            }
                            // 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 (argList.getLongDescription() != null) {
                                // Store the description
                                description = argList.getLongDescription();
                            }
                            // 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.toString();
                                }
                                // 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);
}

Example 2 with ArrayDataType

use of org.ccsds.schema.sois.seds.ArrayDataType in project CCDD by nasa.

the class CcddEDSHandler method setDataType.

/**
 ********************************************************************************************
 * Create the parameter data type and set the specified attributes
 *
 * @param namespace
 *            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 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
 *
 * @param uniqueID
 *            text used to uniquely identify data types with the same name; blank if the data
 *            type has no name conflict
 ********************************************************************************************
 */
private void setDataType(NamespaceType namespace, String parameterName, String dataType, String arraySize, String bitLength, String enumeration, String units, String description, int stringSize, String uniqueID) {
    RootDataType parameterDescription = null;
    // Get the data type set for this name space
    DataTypeSetType dataTypeSet = namespace.getDataTypeSet();
    // enumerated parameter
    if (dataTypeSet == null) {
        // Create the data type set
        dataTypeSet = factory.createDataTypeSetType();
    }
    // Check if the parameter is an array
    if (arraySize != null && !arraySize.isEmpty()) {
        // Create an array type and set its attributes
        ArrayDataType arrayType = factory.createArrayDataType();
        String name = getReferenceByDataType(parameterName, dataType, false);
        arrayType.setName(name + ARRAY);
        arrayType.setDataTypeRef(name + TYPE);
        ArrayDimensionsType dimList = factory.createArrayDimensionsType();
        // Step through each array dimension
        for (int dim : ArrayVariable.getArrayIndexFromSize(arraySize)) {
            // Create a dimension entry for the array type
            DimensionSizeType dimSize = factory.createDimensionSizeType();
            dimSize.setSize(BigInteger.valueOf(dim));
            dimList.getDimension().add(dimSize);
        }
        arrayType.setDimensionList(dimList);
        // Add the data type information to this name space
        dataTypeSet.getArrayDataTypeOrBinaryDataTypeOrBooleanDataType().add(arrayType);
        namespace.setDataTypeSet(dataTypeSet);
    }
    // Check if the parameter has a primitive data type
    if (dataTypeHandler.isPrimitive(dataType)) {
        // Get the EDS data type corresponding to the primitive data type
        EDSDataType edsDataType = getEDSDataType(dataType);
        // Check if the a corresponding EDS data type exists
        if (edsDataType != null) {
            // Check if enumeration parameters are provided
            if (enumeration != null && !enumeration.isEmpty()) {
                // Create an enumeration type and enumeration list
                EnumeratedDataType enumType = factory.createEnumeratedDataType();
                EnumerationListType enumList = createEnumerationList(namespace, 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(IntegerEncodingType.UNSIGNED);
                }
                intEncodingType.setByteOrder(endianess == EndianType.BIG_ENDIAN ? ByteOrderType.BIG_ENDIAN : ByteOrderType.LITTLE_ENDIAN);
                enumType.setIntegerDataEncoding(intEncodingType);
                enumType.setEnumerationList(enumList);
                parameterDescription = enumType;
            } else // Not an enumeration
            {
                switch(edsDataType) {
                    case INTEGER:
                        // Create an integer type
                        IntegerDataType integerType = factory.createIntegerDataType();
                        IntegerDataEncodingType intEncodingType = factory.createIntegerDataEncodingType();
                        IntegerDataTypeRangeType integerRange = factory.createIntegerDataTypeRangeType();
                        // 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(IntegerEncodingType.UNSIGNED);
                        }
                        integerType.setRange(integerRange);
                        intEncodingType.setByteOrder(endianess == EndianType.BIG_ENDIAN ? ByteOrderType.BIG_ENDIAN : ByteOrderType.LITTLE_ENDIAN);
                        integerType.setIntegerDataEncoding(intEncodingType);
                        setUnits(units, integerType);
                        parameterDescription = integerType;
                        break;
                    case FLOAT:
                        // Create a float type
                        FloatDataType floatType = factory.createFloatDataType();
                        FloatDataEncodingType floatEncodingType = factory.createFloatDataEncodingType();
                        FloatDataTypeRangeType floatRange = factory.createFloatDataTypeRangeType();
                        // Set the encoding type based on the size in bytes
                        switch(dataTypeHandler.getSizeInBytes(dataType)) {
                            case 4:
                                floatEncodingType.setEncodingAndPrecision(FloatEncodingAndPrecisionType.IEEE_754_2008_SINGLE);
                                floatRange.setPrecisionRange(FloatPrecisionRangeType.SINGLE);
                                break;
                            case 8:
                                floatEncodingType.setEncodingAndPrecision(FloatEncodingAndPrecisionType.IEEE_754_2008_DOUBLE);
                                floatRange.setPrecisionRange(FloatPrecisionRangeType.DOUBLE);
                                break;
                            case 16:
                                floatEncodingType.setEncodingAndPrecision(FloatEncodingAndPrecisionType.IEEE_754_2008_QUAD);
                                break;
                            default:
                                break;
                        }
                        floatType.setRange(floatRange);
                        floatEncodingType.setByteOrder(endianess == EndianType.BIG_ENDIAN ? ByteOrderType.BIG_ENDIAN : ByteOrderType.LITTLE_ENDIAN);
                        floatType.setFloatDataEncoding(floatEncodingType);
                        setUnits(units, floatType);
                        parameterDescription = floatType;
                        break;
                    case STRING:
                        // Create a string type
                        StringDataType stringType = factory.createStringDataType();
                        StringDataEncodingType stringEncodingType = factory.createStringDataEncodingType();
                        stringEncodingType.setEncoding(StringEncodingType.UTF_8);
                        stringEncodingType.setByteOrder(endianess == EndianType.BIG_ENDIAN ? ByteOrderType.BIG_ENDIAN : ByteOrderType.LITTLE_ENDIAN);
                        stringType.setStringDataEncoding(stringEncodingType);
                        parameterDescription = stringType;
                        break;
                }
            }
        }
    } else // Structure data type
    {
        // Create a container type for the structure
        ContainerDataType containerType = factory.createContainerDataType();
        containerType.setBaseType(getReferenceByDataType(parameterName, dataType, true) + getObjectIdentifier(arraySize));
        parameterName = dataType;
        parameterDescription = containerType;
    }
    // Set the type name
    parameterDescription.setName(parameterName + TYPE + uniqueID);
    // Check is a description exists
    if (description != null && !description.isEmpty()) {
        // Set the description attribute
        parameterDescription.setLongDescription(description);
    }
    // Add the data type information to this name space
    dataTypeSet.getArrayDataTypeOrBinaryDataTypeOrBooleanDataType().add(parameterDescription);
    namespace.setDataTypeSet(dataTypeSet);
}

Example 3 with ArrayDataType

use of org.ccsds.schema.sois.seds.ArrayDataType in project CCDD by nasa.

the class CcddEDSHandler method importStructureTable.

/**
 ********************************************************************************************
 * Build a structure table from the specified telemetry metadata
 *
 * @param namespace
 *            name space
 *
 * @param parameterSet
 *            reference to the parameter set from which to build the structure table
 *
 * @param table
 *            name table name, including the full system path
 *
 * @param hasCommand
 *            true if the name space also has a command set
 *
 * @throws CCDDException
 *             If an input error is detected
 ********************************************************************************************
 */
private void importStructureTable(NamespaceType namespace, List<InterfaceParameterType> parameterSet, String tableName, boolean hasCommand) throws CCDDException {
    List<DescriptionType> memberList = null;
    // Create a table definition for this structure table. If the name space also includes a
    // command set (which creates a command table) then ensure the two tables have different
    // names
    TableDefinition tableDefn = new TableDefinition(tableName + (hasCommand ? "_tlm" : ""), namespace.getLongDescription());
    // Check if a description exists for this structure table
    if (namespace.getLongDescription() != null && !namespace.getLongDescription().isEmpty()) {
        // Store the table's description
        tableDefn.setDescription(namespace.getLongDescription());
    }
    // Set the new structure table's table type name
    tableDefn.setTypeName(structureTypeDefn.getName());
    // Extract the table's name, minus the path, from the name space name
    String typeName = namespace.getName();
    int index = typeName.lastIndexOf("/");
    if (index != -1) {
        typeName = typeName.substring(index + 1);
    }
    typeName += TYPE;
    // container for this structure
    for (RootDataType parmType : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
        // Check if this is the container for the structure's members
        if (parmType instanceof ContainerDataType && parmType.getName().equals(typeName)) {
            // Check if the member list exists
            if (((ContainerDataType) parmType).getEntryList() != null && !((ContainerDataType) parmType).getEntryList().getEntryOrFixedValueEntryOrPaddingEntry().isEmpty()) {
                // Set the reference to the container's member list
                memberList = ((ContainerDataType) parmType).getEntryList().getEntryOrFixedValueEntryOrPaddingEntry();
            }
            // Stop searching since the matching container was found
            break;
        }
    }
    // Step through each telemetry parameter
    for (int parmIndex = 0; parmIndex < parameterSet.size(); parmIndex++) {
        // Get the reference to the parameter in the parameter set
        InterfaceParameterType parm = parameterSet.get(parmIndex);
        // Create a new row of data in the table definition to contain
        // this structure's information. Initialize all columns to
        // blanks except for the variable name
        String[] newRow = new String[structureTypeDefn.getColumnCountVisible()];
        Arrays.fill(newRow, null);
        newRow[variableNameIndex] = parm.getName();
        // definition and that a description exists
        if (descriptionIndex != -1 && parm.getLongDescription() != null) {
            // Store the description for this variable
            newRow[descriptionIndex] = parm.getLongDescription();
        }
        // Add the new row to the table definition
        tableDefn.addData(newRow);
        // name matches the parameter type reference from the parameter set
        for (RootDataType parmType : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
            // parameter type set's name
            if (parm.getType().equals(parmType.getName())) {
                String dataType = null;
                String arraySize = null;
                BigInteger bitLength = null;
                long sizeInBytes = 0;
                String enumeration = null;
                String minimum = null;
                String maximum = null;
                Unit units = null;
                // Check if the parameter is an array data type
                if (parmType instanceof ArrayDataType) {
                    arraySize = "";
                    // Store the reference to the array parameter type
                    ArrayDataType arrayType = (ArrayDataType) parmType;
                    // Step through each dimension for the array variable
                    for (DimensionSizeType dim : ((ArrayDataType) parmType).getDimensionList().getDimension()) {
                        // Build the array size string
                        arraySize += String.valueOf(dim.getSize().longValue()) + ",";
                    }
                    arraySize = CcddUtilities.removeTrailer(arraySize, ",");
                    parmType = null;
                    // the parameter type set in order to locate this data type entry
                    for (RootDataType type : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
                        // type name
                        if (arrayType.getDataTypeRef().equals(type.getName())) {
                            // Store the reference to the array parameter's data type and stop
                            // searching
                            parmType = type;
                            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 IntegerDataType) {
                        // 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)
                        IntegerDataType itlm = (IntegerDataType) parmType;
                        // Get the number of bits occupied by the parameter
                        bitLength = itlm.getIntegerDataEncoding().getSizeInBits();
                        // Check if units exist for this parameter
                        if (itlm.getSemantics() != null && itlm.getSemantics().getUnit() != null) {
                            // Get the parameter units reference
                            units = itlm.getSemantics().getUnit();
                        }
                        // Check if integer encoding is set to 'unsigned'
                        if (itlm.getIntegerDataEncoding().getEncoding() == IntegerEncodingType.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;
                        // Check if the table's member list exists
                        if (memberList != null) {
                            // Step through each member in the member list
                            for (DescriptionType entry : memberList) {
                                // Check if this is the entry for this parameter
                                if (((EntryType) entry).getName().equals(parm.getName() + TYPE)) {
                                    // Get the minimum and maximum values, if present
                                    DerivedTypeRangeType range = ((EntryType) entry).getValidRange();
                                    // Check if the range information exists
                                    if (range != null) {
                                        // Get the minimum and maximum information
                                        MinMaxRangeType minMaxRange = range.getMinMaxRange();
                                        // Check if the minimum value is specified
                                        if (minMaxRange.getMin() != null) {
                                            // Set the minimum value
                                            minimum = minMaxRange.getMin().toString();
                                        }
                                        // Check if the maximum value is specified
                                        if (minMaxRange.getMax() != null) {
                                            // Set the maximum value
                                            maximum = minMaxRange.getMax().toString();
                                        }
                                    }
                                    // Stop searching since the matching parameter was located
                                    break;
                                }
                            }
                        }
                        isInteger = true;
                    } else // Check if the parameter is a floating point data type
                    if (parmType instanceof FloatDataType) {
                        // Get the float parameter attributes
                        FloatDataType ftlm = (FloatDataType) parmType;
                        switch(ftlm.getFloatDataEncoding().getEncodingAndPrecision()) {
                            case IEEE_754_2008_SINGLE:
                                sizeInBytes = 4;
                                break;
                            case IEEE_754_2008_DOUBLE:
                                sizeInBytes = 8;
                                break;
                            case IEEE_754_2008_QUAD:
                                sizeInBytes = 16;
                                break;
                            default:
                                break;
                        }
                        // Check if units exist for this parameter
                        if (ftlm.getSemantics() != null && ftlm.getSemantics().getUnit() != null) {
                            // Get the parameter units reference
                            units = ftlm.getSemantics().getUnit();
                        }
                        // Check if the table's member list exists
                        if (memberList != null) {
                            // Step through each member in the member list
                            for (DescriptionType entry : memberList) {
                                // Check if this is the entry for this parameter
                                if (((EntryType) entry).getName().equals(parm.getName())) {
                                    // Get the minimum and maximum values, if present
                                    DerivedTypeRangeType range = ((EntryType) entry).getValidRange();
                                    // Check if the range information exists
                                    if (range != null) {
                                        // Get the minimum and maximum information
                                        MinMaxRangeType minMaxRange = range.getMinMaxRange();
                                        // Check if the minimum value is specified
                                        if (minMaxRange.getMin() != null) {
                                            // Set the minimum value
                                            minimum = minMaxRange.getMin().toString();
                                        }
                                        // Check if the maximum value is specified
                                        if (minMaxRange.getMax() != null) {
                                            // Set the maximum value
                                            maximum = minMaxRange.getMax().toString();
                                        }
                                    }
                                    // Stop searching since the matching parameter was located
                                    break;
                                }
                            }
                        }
                        isFloat = true;
                    } else // Check if the parameter is a string data type
                    if (parmType instanceof StringDataType) {
                        // Get the string parameter attributes
                        StringDataType stlm = (StringDataType) parmType;
                        sizeInBytes = stlm.getLength().longValue();
                        // Check if units exist for this parameter
                        if (stlm.getSemantics() != null && stlm.getSemantics().getUnit() != null) {
                            // Get the parameter units reference
                            units = stlm.getSemantics().getUnit();
                        }
                        isString = true;
                    } else // Check if the parameter is an enumerated data type
                    if (parmType instanceof EnumeratedDataType) {
                        // Get the enumeration parameters
                        EnumeratedDataType etlm = (EnumeratedDataType) parmType;
                        EnumerationListType 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();
                            // Check if units exist for this parameter
                            if (etlm.getSemantics() != null && etlm.getSemantics().getUnit() != null) {
                                // Get the parameter units reference
                                units = etlm.getSemantics().getUnit();
                            }
                            // Check if integer encoding is set to 'unsigned'
                            if (etlm.getIntegerDataEncoding().getEncoding() == IntegerEncodingType.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 // reference
                    if (parmType instanceof ContainerDataType && ((ContainerDataType) parmType).getEntryList() != null) {
                        // Get the reference to the container's base type, which is the name
                        // space path
                        dataType = ((ContainerDataType) parmType).getBaseType();
                        // it begins with a '/'. This beginning '/' is stripped off
                        if (dataType.startsWith("/")) {
                            // Remove the initial '/'
                            dataType = dataType.substring(1);
                        }
                        // The variable name must be stripped from the name space 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 (parm.getLongDescription() != null) {
                        // Store the description
                        tableDefn.getData().set(parmIndex * numStructureColumns + descriptionIndex, parm.getLongDescription());
                    }
                    // Check if a units exists
                    if (units != null && !units.value().isEmpty()) {
                        // Store the units for this variable
                        tableDefn.getData().set(parmIndex * numStructureColumns + unitsIndex, units.value());
                    }
                }
                // 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;
            }
        }
    }
    // Add the structure table definition to the list
    tableDefinitions.add(tableDefn);
}