如何通过IBM Rational Rhapsody Java API提取C++类的#include信息

Got it, let's tackle this problem step by step. You already have the Java API working to pull operations and attributes from your Rational Rhapsody C++ classes, but need to grab the associated #include directives to generate gmock mocks for unit testing Foo with Bar's mock. Here's how to make it happen:

Step 1: Extract #include Directives via Rhapsody Java API #

Rational Rhapsody stores #include references in two key places: explicit includes configured on the class itself, and implicit includes tied to the types your class uses (like uint64_t requiring stdint.h). You'll need to capture both.

1.1 Grab Explicit Class Includes #

Rhapsody's IRPClass interface has a method getCPPIncludeFiles() that returns all explicitly configured includes for the class. This is exactly what you need for cases where the class directly references a header:

// Assume you've already retrieved your target IRPClass (e.g., Bar)
IRPCollection explicitIncludes = barClass.getCPPIncludeFiles();
Iterator<?> includeIterator = explicitIncludes.iterator();

// Store includes in a set to avoid duplicates later
Set<String> allIncludes = new HashSet<>();

while (includeIterator.hasNext()) {
    String includeLine = (String) includeIterator.next();
    allIncludes.add(includeLine); // Adds lines like "#include \"stdint.h\""
}

1.2 Capture Implicit Includes from Type Dependencies #

If your class uses types from other headers (like uint64_t), you'll need to traverse the class's attributes, operation parameters, and return types to pull their associated headers. Use getCPPHeaderFile() on each IRPType to get the required include:

// Traverse class operations
IRPCollection operations = barClass.getOperations();
Iterator<?> opIterator = operations.iterator();

while (opIterator.hasNext()) {
    IRPOperation op = (IRPOperation) opIterator.next();
    
    // Check return type
    IRPType returnType = op.getReturnType();
    if (returnType != null) {
        String header = returnType.getCPPHeaderFile();
        if (header != null && !header.isEmpty()) {
            allIncludes.add("#include \"" + header + "\"");
        }
    }
    
    // Check operation parameters
    IRPCollection params = op.getParameters();
    Iterator<?> paramIterator = params.iterator();
    while (paramIterator.hasNext()) {
        IRPParameter param = (IRPParameter) paramIterator.next();
        IRPType paramType = param.getType();
        if (paramType != null) {
            String header = paramType.getCPPHeaderFile();
            if (header != null && !header.isEmpty()) {
                allIncludes.add("#include \"" + header + "\"");
            }
        }
    }
}

// Repeat the same logic for class attributes (if needed)
IRPCollection attributes = barClass.getAttributes();
Iterator<?> attrIterator = attributes.iterator();
while (attrIterator.hasNext()) {
    IRPAttribute attr = (IRPAttribute) attrIterator.next();
    IRPType attrType = attr.getType();
    if (attrType != null) {
        String header = attrType.getCPPHeaderFile();
        if (header != null && !header.isEmpty()) {
            allIncludes.add("#include \"" + header + "\"");
        }
    }
}

Step 2: Generate the gmock Mock Class #

Once you have all the required includes, you can dynamically build the mock class code. We'll use a StringBuilder to assemble the output, including the gmock header and MOCK_METHOD macros for each operation:

// Start building the mock class content
StringBuilder mockCode = new StringBuilder();
mockCode.append("// file Bar_MOCK.h\n\n");

// Add gmock's required header first
allIncludes.add("#include <gmock/gmock.h>");

// Write all unique includes
for (String include : allIncludes) {
    mockCode.append(include).append("\n");
}

mockCode.append("\nclass Bar_MOCK {\n");
mockCode.append("public:\n");

// Generate MOCK_METHOD for each operation
Iterator<?> opIterator = barClass.getOperations().iterator();
while (opIterator.hasNext()) {
    IRPOperation op = (IRPOperation) opIterator.next();
    String opName = op.getName();
    int paramCount = op.getParameters().count();
    
    // Get C++-style return type (handles pointers/references correctly)
    String returnType = op.getReturnType() != null 
        ? op.getReturnType().getCPPType() 
        : "void";
    
    // Build parameter list string
    StringBuilder paramList = new StringBuilder();
    IRPCollection params = op.getParameters();
    Iterator<?> paramIterator = params.iterator();
    
    while (paramIterator.hasNext()) {
        IRPParameter param = (IRPParameter) paramIterator.next();
        String paramType = param.getType().getCPPType();
        String paramName = param.getName();
        
        paramList.append(paramType).append(" ").append(paramName);
        if (paramIterator.hasNext()) {
            paramList.append(", ");
        }
    }
    
    // Append the MOCK_METHOD macro
    mockCode.append("    MOCK_METHOD").append(paramCount)
            .append("(").append(opName).append(", ")
            .append(returnType).append("(").append(paramList).append("));\n");
}

mockCode.append("};");

// Output the mock code (or write to a file)
System.out.println(mockCode.toString());

Key Notes #

• Duplicate Prevention: Using a HashSet for allIncludes ensures you don't have repeated #include lines in your mock.
• Pointer/Reference Handling: Using getCPPType() instead of getName() ensures you get the correct C++ type syntax (like uint64_t* instead of just uint64_t).
• Customization: You can extend this logic to handle other gmock features (like default parameters, const methods) by checking additional properties on IRPOperation (e.g., isConst()).

内容的提问来源于stack exchange，提问作者RichardSchorrig