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

Example 1 with DataTypeSetType

use of org.ccsds.schema.sois.seds.DataTypeSetType 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 2 with DataTypeSetType

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

the class CcddEDSHandler method buildNamespaces.

/**
 ********************************************************************************************
 * Build the name spaces for the list of tables specified
 *
 * @param tableNames
 *            array of table names
 *
 * @param includeVariablePaths
 *            true to include the variable path for each variable in a structure table, both in
 *            application format and using the user-defined separator characters
 *
 * @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 buildNamespaces(String[] tableNames, boolean includeVariablePaths, CcddVariableSizeAndConversionHandler variableHandler, String[] separators) {
    // Build the data field information for all fields
    fieldHandler.buildFieldInformation(null);
    // Get the names of the tables representing the CCSDS telemetry and command headers
    tlmHeaderTable = fieldHandler.getFieldValue(CcddFieldHandler.getFieldProjectName(), InputDataType.XML_TLM_HDR);
    cmdHeaderTable = fieldHandler.getFieldValue(CcddFieldHandler.getFieldProjectName(), InputDataType.XML_CMD_HDR);
    // Get the command header argument names for the application ID and the command function
    // code. These are stored as project-level data fields
    String ccsdsAppID = fieldHandler.getFieldValue(CcddFieldHandler.getFieldProjectName(), InputDataType.XML_APP_ID);
    String ccsdsFuncCode = fieldHandler.getFieldValue(CcddFieldHandler.getFieldProjectName(), InputDataType.XML_FUNC_CODE);
    // Step through each table name
    for (String tableName : tableNames) {
        // Check if this is a child (instance) table
        if (!TableInformation.isPrototype(tableName)) {
            // Get the prototype of the instance table. Only prototypes of the tables are
            // used to create the space systems
            tableName = TableInformation.getPrototypeName(tableName);
            // Get the name of the system to which this table belongs from the table's
            // system path data field (if present)
            String systemPath = cleanSystemPath(fieldHandler.getFieldValue(tableName, InputDataType.SYSTEM_PATH));
            // created
            if (searchNamespacesForName(systemPath, tableName) != 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()) {
            // 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 = cleanSystemPath(fieldHandler.getFieldValue(tableName, InputDataType.SYSTEM_PATH));
                // Add the name space
                NamespaceType namespace = addNamespace(systemPath, tableName, tableInfo.getDescription());
                // Check if this is a structure table
                if (typeDefn.isStructure()) {
                    // 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(namespace, tableInfo, varColumn, typeColumn, sizeColumn, minColumn, maxColumn, isTlmHeaderTable, applicationID, ccsdsAppID);
                    // 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 data sheet
                            addParameter(namespace, rowData[varColumn], rowData[typeColumn], rowData[sizeColumn], rowData[bitColumn], (enumColumn != -1 && !rowData[enumColumn].isEmpty() ? rowData[enumColumn] : null), (unitsColumn != -1 && !rowData[unitsColumn].isEmpty() ? rowData[unitsColumn] : null), (descColumn != -1 && !rowData[descColumn].isEmpty() ? rowData[descColumn] : null), (dataTypeHandler.isString(rowData[typeColumn]) && !rowData[sizeColumn].isEmpty() ? Integer.valueOf(rowData[sizeColumn].replaceAll("^.*(\\d+)$", "$1")) : 1));
                        }
                    }
                } else // This is a command table
                {
                    // Check if this is the command header table
                    if (tableName.equals(cmdHeaderTable)) {
                        // Store the command header's path
                        cmdHeaderPath = systemPath;
                    }
                    // Add the command(s) from this table to the data sheet
                    addNamespaceCommands(namespace, tableInfo, tableName.equals(cmdHeaderTable), applicationID, ccsdsAppID, ccsdsFuncCode);
                }
            }
        }
    }
    // Step through each table name
    for (String tableName : tableNames) {
        // Get the prototype for the child
        tableName = TableInformation.getPrototypeName(tableName);
        // Get the name of the system to which this table belongs from the table's
        // system path data field (if present)
        String systemPath = cleanSystemPath(fieldHandler.getFieldValue(tableName, InputDataType.SYSTEM_PATH));
        // Get the name space for this table
        NamespaceType namespace = searchNamespacesForName(systemPath, tableName);
        // Check if the table's name space exists
        if (namespace != null) {
            // Step through the each parameter type
            for (RootDataType type : namespace.getDataTypeSet().getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
                // base type it's a reference to a child structure
                if (type instanceof ContainerDataType && ((ContainerDataType) type).getBaseType() != null) {
                    // Get the base type, which has the name space path for the child structure
                    String typeName = ((ContainerDataType) type).getBaseType();
                    // Get the beginning of the last portion of the path, which is the
                    // structure data type
                    int index = ((ContainerDataType) type).getBaseType().lastIndexOf("/");
                    // Check if the structure data type exists
                    if (index != -1) {
                        // Remove the structure data type, leaving only the name space path to
                        // the child structure's definition
                        typeName = typeName.substring(0, index);
                    }
                    // Get the name space for the child structure's definition
                    NamespaceType nmspc = searchNamespacesForName(null, typeName);
                    // Check if the name space exists
                    if (nmspc != null) {
                        DataTypeSetType dataTypeSet = nmspc.getDataTypeSet();
                        // Check if the child's data type set exists
                        if (dataTypeSet != null && !dataTypeSet.getArrayDataTypeOrBinaryDataTypeOrBooleanDataType().isEmpty()) {
                            // Step through each data type
                            for (RootDataType rootData : dataTypeSet.getArrayDataTypeOrBinaryDataTypeOrBooleanDataType()) {
                                // Check if this is the container with the structure's members
                                if (rootData instanceof ContainerDataType && rootData.getName().equals(type.getName())) {
                                    // Set the parent structure table's list of members of the
                                    // child structure using the child structure definition's
                                    // list, and stop searching
                                    ((ContainerDataType) type).setEntryList(((ContainerDataType) rootData).getEntryList());
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Example 3 with DataTypeSetType

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

the class CcddEDSHandler method addParameterContainer.

/**
 ********************************************************************************************
 * Add the parameter container
 *
 * @param namespace
 *            name space
 *
 * @param tableInfo
 *            table information reference
 *
 * @param varColumn
 *            variable name column index (model coordinates)
 *
 * @param typeColumn
 *            data type column index (model coordinates)
 *
 * @param sizeColumn
 *            array size column index (model coordinates)
 *
 * @param minColumn
 *            minimum value column index (model coordinates)
 *
 * @param maxColumn
 *            maximum value column index (model coordinates)
 *
 * @param isTlmHeader
 *            true if this table represents the CCSDS telemetry header
 *
 * @param applicationID
 *            application ID
 *
 * @param ccsdsAppID
 *            name of the command header argument containing the application ID
 ********************************************************************************************
 */
private void addParameterContainer(NamespaceType namespace, TableInformation tableInfo, int varColumn, int typeColumn, int sizeColumn, int minColumn, int maxColumn, boolean isTlmHeader, // TODO WHERE DOES THIS GET PUT?
String applicationID, // TODO WHERE DOES THIS GET PUT?
String ccsdsAppID) {
    ContainerDataType containerType = null;
    EntryListType entryList = factory.createEntryListType();
    // Step through each row of data in the structure table
    for (String[] rowData : tableInfo.getData()) {
        // used to create the list)
        if (!ArrayVariable.isArrayMember(rowData[varColumn])) {
            // TODO A REFERENCE IN A CONTAINER TO A STRUCTURE THAT CONTAINS AN ARRAY THROWS A
            // NULL POINTER EXCEPTION IN THE EDS VIEWER (UNDER THE DATA TYPES TAB WHEN THE
            // CONTAINER IS EXPANDED)
            // Store the parameter reference in the list
            EntryType entryType = factory.createEntryType();
            entryType.setName(rowData[varColumn]);
            entryType.setType(getReferenceByDataType(rowData[varColumn], rowData[typeColumn], !dataTypeHandler.isPrimitive(rowData[typeColumn])) + getObjectIdentifier(rowData[sizeColumn]));
            // Check if a minimum or maximum value exists
            if ((minColumn != -1 && !rowData[minColumn].isEmpty()) || (maxColumn != -1 && !rowData[maxColumn].isEmpty())) {
                DerivedTypeRangeType range = factory.createDerivedTypeRangeType();
                MinMaxRangeType minMaxRange = factory.createMinMaxRangeType();
                minMaxRange.setRangeType(RangeType.INCLUSIVE_MIN_INCLUSIVE_MAX);
                // Set the flag if the parameter is in integer data type
                boolean isInteger = dataTypeHandler.isInteger(rowData[typeColumn]);
                // Check if a minimum value is specified
                if (minColumn != -1 && !rowData[minColumn].isEmpty()) {
                    // Set the minimum value
                    minMaxRange.setMin(isInteger ? BigDecimal.valueOf(Integer.valueOf(rowData[minColumn])) : BigDecimal.valueOf(Float.valueOf(rowData[minColumn])));
                }
                // Check if a maximum value is specified
                if (maxColumn != -1 && !rowData[maxColumn].isEmpty()) {
                    // Set the maximum value
                    minMaxRange.setMax(isInteger ? BigDecimal.valueOf(Integer.valueOf(rowData[maxColumn])) : BigDecimal.valueOf(Float.valueOf(rowData[maxColumn])));
                }
                // Set the range
                range.setMinMaxRange(minMaxRange);
                entryType.setValidRange(range);
            }
            entryList.getEntryOrFixedValueEntryOrPaddingEntry().add(entryType);
        }
    }
    // Check if any parameters exist
    if (!entryList.getEntryOrFixedValueEntryOrPaddingEntry().isEmpty()) {
        // Check if the parameter sequence container set hasn't been created
        if (containerType == null) {
            // Create the parameter sequence container set
            containerType = factory.createContainerDataType();
        }
        // Check if this is the telemetry header
        if (isTlmHeader) {
            containerType.setName(tlmHeaderTable + TYPE);
            containerType.setAbstract(true);
        } else // Not the telemetry header
        {
            containerType.setName(tableInfo.getPrototypeName() + TYPE);
        }
        // Store the parameters in the parameter sequence container
        containerType.setEntryList(entryList);
    }
    // Check if any parameters exist
    if (containerType != 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();
        }
        // Add the parameters to the system
        dataTypeSet.getArrayDataTypeOrBinaryDataTypeOrBooleanDataType().add(containerType);
        namespace.setDataTypeSet(dataTypeSet);
    }
}