Examples with Member org.omg.space.xtce.AggregateDataType.MemberList.Member used on opensource projects

Example 1 with Member

use of org.omg.space.xtce.AggregateDataType.MemberList.Member 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);
}

Example 2 with Member

use of org.omg.space.xtce.AggregateDataType.MemberList.Member in project CCDD by nasa.

the class CcddXTCEHandler method buildSpaceSystems.

/**
 ********************************************************************************************
 * Build the space systems
 *
 * @param node
 *            current tree node
 *
 * @param variableHandler
 *            variable handler class reference; null if includeVariablePaths is false
 *
 * @param separators
 *            string array containing the variable path separator character(s), show/hide data
 *            types flag ('true' or 'false'), and data type/variable name separator
 *            character(s); null if includeVariablePaths is false
 ********************************************************************************************
 */
private void buildSpaceSystems(String[] tableNames, CcddVariableSizeAndConversionHandler variableHandler, String[] separators) {
    List<StructureMemberList> memberLists = new ArrayList<StructureMemberList>();
    // Step through each table name
    for (String tableName : tableNames) {
        // Check if this is a child (instance) table
        if (!TableInformation.isPrototype(tableName)) {
            // TODO THIS NEEDS TO CHANGE SO THAT INSTANCE VALUES CAN BE USED
            // Get the prototype of the instance table. Only prototypes of the tables are
            // used to create the space systems
            tableName = TableInformation.getPrototypeName(tableName);
            // created
            if (getSpaceSystemByName(tableName, project.getValue()) != null) {
                // Skip this table since it's space system has already been created
                continue;
            }
        }
        // Get the information from the database for the specified table
        TableInformation tableInfo = dbTable.loadTableData(tableName, true, false, true, parent);
        // Check if the table's data successfully loaded
        if (!tableInfo.isErrorFlag()) {
            // TODO IF RATE INFORMATION GETS USED THEN THE PROTOTYPE DATA IS REQUIRED. SEPARATE
            // SPACE SYSTEMS FOR EACH INSTANCE MAY THEN BE NEEDED. THE SAME ISSUE APPLIES TO
            // OTHER INSTANCE VALUES (E.G., MIN & MAX) - CAN'T REFERENCE THE PROTOTYPE TO GET
            // THIS INFORMATION; INSTEAD NEED A SPACE SYSTEM FOR THE INSTANCE
            // Get the table type and from the type get the type definition. The type
            // definition can be a global parameter since if the table represents a structure,
            // then all of its children are also structures, and if the table represents
            // commands or other table type then it is processed within this nest level
            typeDefn = tableTypeHandler.getTypeDefinition(tableInfo.getType());
            // Check if the table type represents a structure or command
            if (typeDefn != null && (typeDefn.isStructure() || typeDefn.isCommand())) {
                // Replace all macro names with their corresponding values
                tableInfo.setData(macroHandler.replaceAllMacros(tableInfo.getData()));
                // Get the application ID data field value, if present
                String applicationID = fieldHandler.getFieldValue(tableName, InputDataType.MESSAGE_ID);
                // Get the name of the system to which this table belongs from the table's
                // system path data field (if present)
                String systemPath = fieldHandler.getFieldValue(tableName, InputDataType.SYSTEM_PATH);
                // Initialize the parent system to be the root (top-level) system
                SpaceSystemType parentSystem = project.getValue();
                // Check if a system path exists
                if (systemPath != null) {
                    // Step through each system name in the path
                    for (String systemName : systemPath.split("\\s*/\\s*")) {
                        // if present)
                        if (!systemName.isEmpty()) {
                            // Search the existing space systems for one with this system's
                            // name (if none exists then use the root system's name)
                            SpaceSystemType existingSystem = getSpaceSystemByName(systemName, parentSystem);
                            // Set the parent system to the existing system if found, else
                            // create a new space system using the name from the table's system
                            // path data field
                            parentSystem = existingSystem == null ? addSpaceSystem(parentSystem, systemName, null, classification2Attr, validationStatusAttr, versionAttr) : existingSystem;
                        }
                    }
                }
                // Add the space system
                parentSystem = addSpaceSystem(parentSystem, tableName, tableInfo.getDescription(), classification3Attr, validationStatusAttr, versionAttr);
                // Check if this is a structure table
                if (typeDefn.isStructure()) {
                    MemberList memberList = factory.createAggregateDataTypeMemberList();
                    // Get the default column indices
                    int varColumn = typeDefn.getColumnIndexByInputType(InputDataType.VARIABLE);
                    int typeColumn = typeDefn.getColumnIndexByInputType(InputDataType.PRIM_AND_STRUCT);
                    int sizeColumn = typeDefn.getColumnIndexByInputType(InputDataType.ARRAY_INDEX);
                    int bitColumn = typeDefn.getColumnIndexByInputType(InputDataType.BIT_LENGTH);
                    int enumColumn = typeDefn.getColumnIndexByInputType(InputDataType.ENUMERATION);
                    int descColumn = typeDefn.getColumnIndexByInputType(InputDataType.DESCRIPTION);
                    int unitsColumn = typeDefn.getColumnIndexByInputType(InputDataType.UNITS);
                    int minColumn = typeDefn.getColumnIndexByInputType(InputDataType.MINIMUM);
                    int maxColumn = typeDefn.getColumnIndexByInputType(InputDataType.MAXIMUM);
                    // Set the flag to indicate if this is the telemetry header table
                    boolean isTlmHeaderTable = tableName.equals(tlmHeaderTable);
                    // Check if this is the telemetry header table
                    if (isTlmHeaderTable) {
                        // Store the telemetry header's path
                        tlmHeaderPath = systemPath;
                    }
                    // Export the parameter container for this structure
                    addParameterContainer(parentSystem, tableInfo, varColumn, typeColumn, sizeColumn, isTlmHeaderTable, applicationID);
                    // Step through each row in the structure table
                    for (String[] rowData : tableInfo.getData()) {
                        // used to define the array)
                        if (!ArrayVariable.isArrayMember(rowData[varColumn])) {
                            // Add the variable to the space system
                            addParameter(parentSystem, rowData[varColumn], rowData[typeColumn], rowData[sizeColumn], rowData[bitColumn], (enumColumn != -1 && !rowData[enumColumn].isEmpty() ? rowData[enumColumn] : null), (unitsColumn != -1 && !rowData[unitsColumn].isEmpty() ? rowData[unitsColumn] : null), (minColumn != -1 && !rowData[minColumn].isEmpty() ? rowData[minColumn] : null), (maxColumn != -1 && !rowData[maxColumn].isEmpty() ? rowData[maxColumn] : null), (descColumn != -1 && !rowData[descColumn].isEmpty() ? rowData[descColumn] : null), (dataTypeHandler.isString(rowData[typeColumn]) && !rowData[sizeColumn].isEmpty() ? Integer.valueOf(rowData[sizeColumn].replaceAll("^.*(\\d+)$", "$1")) : 1));
                            // Use the variable name to create an aggregate list member and add
                            // it to the member list. The list is used if this structure is
                            // referenced as a data type in another structure
                            Member member = new Member();
                            member.setName(rowData[varColumn]);
                            member.setTypeRef("/" + project.getValue().getName() + (systemPath == null || systemPath.isEmpty() ? "" : "/" + systemPath) + "/" + tableName + "/" + getNameByDataType(rowData[varColumn], rowData[typeColumn]) + TYPE);
                            memberList.getMember().add(member);
                        }
                    }
                    // Check if any variables exists in the structure table
                    if (!memberList.getMember().isEmpty()) {
                        // Create a structure member list using the table's aggregate member
                        // list
                        memberLists.add(new StructureMemberList(tableName, memberList));
                    }
                } else // This is a command table
                {
                    // Get the list containing the associated column indices for each argument
                    // grouping
                    commandArguments = typeDefn.getAssociatedCommandArgumentColumns(false);
                    // Set the flag to indicate if this is the command header table
                    boolean isCmdHeaderTable = tableName.equals(cmdHeaderTable);
                    // Check if this is the command header table
                    if (isCmdHeaderTable) {
                        // Store the command header's path
                        cmdHeaderPath = systemPath;
                    }
                    // Add the command(s) from this table to the parent system
                    addSpaceSystemCommands(parentSystem, tableInfo, tableName.equals(cmdHeaderTable), applicationID);
                }
            }
        }
    }
    // Step through each table name
    for (String tableName : tableNames) {
        // Get the prototype for the child
        tableName = TableInformation.getPrototypeName(tableName);
        // Get the space system for this table
        SpaceSystemType spaceSystem = getSpaceSystemByName(tableName, project.getValue());
        // Check if the system was found and it has telemetry data
        if (spaceSystem != null && spaceSystem.getTelemetryMetaData() != null) {
            // Step through each parameter type
            for (NameDescriptionType type : spaceSystem.getTelemetryMetaData().getParameterTypeSet().getStringParameterTypeOrEnumeratedParameterTypeOrIntegerParameterType()) {
                // Check if the type is an aggregate (i.e., a structure reference)
                if (type instanceof AggregateDataType) {
                    // Remove the trailing text added to the table name that flags it as a type
                    // or array
                    String typeName = type.getName().substring(0, type.getName().lastIndexOf("_"));
                    // Step through each structure member list
                    for (StructureMemberList structMemList : memberLists) {
                        // Check if the aggregate refers to this structure
                        if (typeName.equals(structMemList.structureName)) {
                            // Set the aggregate's member list to this structure member list
                            // and stop searching
                            ((AggregateDataType) type).setMemberList(structMemList.memberList);
                            break;
                        }
                    }
                }
            }
        }
    }
}