如何使用TPTP中的IDatapool

最新推荐文章于 2016-04-12 10:40:44 发布

转载最新推荐文章于 2016-04-12 10:40:44 发布 · 827 阅读

文章标签：

#TPTP IDatapool

Test tools 专栏收录该内容

56 篇文章

订阅专栏

本文介绍如何使用Java代码读取和编辑Rational Datapools中的TPTP格式数据池，包括读取数据池内容、捕获列头信息、遍历数据池并修改值的操作。

原文地址：http://www.ibm.com/developerworks/rational/library/programmatically-modify-rational-datapools/index.html

The Java code snippet in Listing 7 displays a simple example of reading a TPTP format datapool.

Listing 7. TPTP datapool, example

// set the Datapool File value
    File inputTptpFile = new File(
        "/Datapool_Workspace/Common/datapool/TPTP_Datapool.datapool");
    System.out.println("Read a TPTP (RPT/RST) format Datapool: " + 
        inputTptpFile.getAbsolutePath());

    try {
        // create an IDatapoolFactory object
        IDatapoolFactory tptpDatapoolFactory = new Common_DatapoolFactoryImpl();
        // create an Datapool object
        IDatapool tptpDatapool = 
            (IDatapool) tptpDatapoolFactory.load(inputTptpFile, true);

        // capture the Datapool column header values 
        int datapoolColumnCount = tptpDatapool.getVariableCount();
        String[] header = new String[datapoolColumnCount];
        aStringBuilder.append("\nHEADER  :: ");
        for (int i = 0; i < datapoolColumnCount; i++) {
            header[i] = tptpDatapool.getVariable(i).getName();
            aStringBuilder.append(header[i] + " :: ");
        }
        System.out.println(aStringBuilder.toString());

        // Create an IDatapoolIterator object and populate with 
        //    the Datapool as an iterator
        IDatapoolIterator tptpDatapoolIterator = tptpDatapoolFactory.
            open(tptpDatapool, 
        "org.eclipse.hyades.datapool.iterator.DatapoolIteratorSequentialPrivate");

        // initialize datapool iterator    
        tptpDatapoolIterator.dpInitialize(tptpDatapool, 0);
        int count = 1; // int counter for demonstration purposes only
        while(!tptpDatapoolIterator.dpDone()) {
            // reset the temporary container for captured values
            aStringBuilder.setLength(0);
            aStringBuilder.append("ROW #" + count + "  :: ");
            String[] nextRow = new String[datapoolColumnCount];
            for (int i = 0; i < datapoolColumnCount; i++) {
                /* NOTE: this example assumes value to be of type String
                 *    value can be captured via:
                 *    IDatapool.getVariable(int).getSuggestedType() */
                nextRow[i] = tptpDatapoolIterator.dpCurrent().getCell(
                    header[i]).getStringValue();
                aStringBuilder.append(nextRow[i] + " :: ");
            }
            tptpDatapoolIterator.dpNext();
            count++;
            System.out.println(aStringBuilder.toString());
            // unload the Datapool
            tptpDatapoolFactory.unload(tptpDatapool);
        }
    } catch (DatapoolException e) {
        e.printStackTrace();
    }

This is a simple approach to capturing the contents of a TPTP format datapool and, in this case, writing it to the console. At this point, you can iterate through your datapool, using the values as you see fit, or build in logic to perform a search for specific values. Field types can also be captured to ensure integrity of data types when updating the values.

Updating a TPTP datapool

The datapool reader program uses this class:
org.eclipse.hyades.execution.runtime.datapool.IDatapool

To extend the above program that reads a datapool to directly edit the datapool, use this class:
org.eclipse.hyades.edit.datapool.IDatapool

This is part of the TPTP internal API (see the Public API Specification for reference).

Minor modifications to this code will give you the ability to perform modifications to the datapool. The first item of note to perform anedit rather than a read is changing the references in the import section of the program.

Listing 8. TPTP datapool edit imports

        /* NOTE: To update a Datapool the edit version of the classes must be used */
        import org.eclipse.hyades.edit.datapool.IDatapool;
        import org.eclipse.hyades.edit.datapool.IDatapoolFactory;
        //import org.eclipse.hyades.execution.runtime.datapool.IDatapool;
        //import org.eclipse.hyades.execution.runtime.datapool.IDatapoolFactory;

The edit classes behave slightly different from the runtime classes. The first notable change is located at the start of the try or catch block, as the example in Listing 9 shows.

Listing 9. TPTP datapool edit instantiation

        try {
            // create an org.eclipse.hyades.edit.datapool.IDatapoolFactory object
            IDatapoolFactory tptpDatapoolFactory = new Common_DatapoolFactoryImpl();
            // create an org.eclipse.hyades.edit.datapool.IDatapool object
            IDatapool tptpDatapool = (IDatapool) tptpDatapoolFactory.loadForEdit(
                inputTptpFile, true);

When creating the IDatapool object, the file is loaded through the loadForEdit(File, Boolean) method. Also, when creating the IDatapoolIterator, different behavior is found in the edit classes (Listing 10).

Listing 10. TPTP datapool edit iterator

                /* Create an IDatapoolIterator object and populate with the Datapool 
             *     as an iterator
             * NOTE: for edit variations of the IDatapool* objects the IDatapoolFactory
             *     must be cast to "Common_DatapoolFactoryImpl" to make the appropriate 
             * open(IDatapool, String) method visible*/
            IDatapoolIterator tptpDatapoolIterator = 
               ((Common_DatapoolFactoryImpl)tptpDatapoolFactory).open(tptpDatapool, 
               "org.eclipse.hyades.datapool.iterator.DatapoolIteratorSequentialPrivate");

As the comment states, the IDatapoolFactory must be cast to Common_DatapoolFactoryImpl to provide access to the open(IDatapool, String) method. The code snippet in Listing 1 illustrates the capture of a specific cell in the datapool, and then changing the value.

Listing 11. TPTP datapool edit iteration

                for (int i = 0; i < datapoolColumnCount; i++) {
                // look for the last column in the Datapool -- to be updated
                if (i + 1 == tptpDatapool.getVariableCount()) {
                    // create a new value
                    String newCellValue = "Updated value for row " + count +
                        " at " + dateFormat.format(new Date().getTime());
                    // capture the cell as an IDatapoolCell
                    IDatapoolCell aCell = (IDatapoolCell)tptpDatapoolIterator.
                        dpCurrent().getCell(header[i]);
                    aCell.setCellValue(newCellValue);
                    // sleep to demonstrate timestamp update in Datapool
                    Thread.sleep(1000);
                }
                nextRow[i] = tptpDatapoolIterator.dpCurrent().
                    getCell(header[i]).getStringValue();

After processing the datapool, perform a save and unload on the datapool (Listing 12).

Listing 12. TPTP datapool edit finalization

                // save updates to the Datapool file 
                tptpDatapoolFactory.save(tptpDatapool); 
                tptpDatapoolFactory.unload(tptpDatapool);