com.aspose.words

Example:

public void order(boolean differentFirstPageHeaderFooter) throws Exception {
    Document doc = new Document(getMyDir() + "Header and footer types.docx");

    Section firstPageSection = doc.getFirstSection();

    ReplaceLog logger = new ReplaceLog();
    FindReplaceOptions options = new FindReplaceOptions();
    {
        options.setReplacingCallback(logger);
    }

    // Using a different header/footer for the first page will affect the search order.
    firstPageSection.getPageSetup().setDifferentFirstPageHeaderFooter(differentFirstPageHeaderFooter);
    doc.getRange().replace(Pattern.compile("(header|footer)"), "", options);

    if (differentFirstPageHeaderFooter)
        Assert.assertEquals("First headerFirst footerSecond headerSecond footerThird headerThird footer",
                logger.Text().replace("\r", ""));
    else
        Assert.assertEquals("Third headerFirst headerThird footerFirst footerSecond headerSecond footer",
                logger.Text().replace("\r", ""));
}

@DataProvider(name = "orderDataProvider")
public static Object[][] orderDataProvider() throws Exception {
    return new Object[][]
            {
                    {false},
                    {true},
            };
}

/// <summary>
/// During a find-and-replace operation, records the contents of every node that has text that the operation 'finds',
/// in the state it is in before the replacement takes place.
/// This will display the order in which the text replacement operation traverses nodes.
/// </summary>
private static class ReplaceLog implements IReplacingCallback {
    public int replacing(ReplacingArgs args) {
        mTextBuilder.append(args.getMatchNode().getText());
        return ReplaceAction.SKIP;
    }

    public String Text() {
        return mTextBuilder.toString();
    }

    private final StringBuilder mTextBuilder = new StringBuilder();
}

Example:

public void replaceWithCallback() throws Exception
{
    Document doc = new Document();
    DocumentBuilder builder = new DocumentBuilder(doc);

    builder.writeln("Our new location in New York City is opening tomorrow. " +
                    "Hope to see all our NYC-based customers at the opening!");

    // We can use a "FindReplaceOptions" object to modify the find-and-replace process.
    FindReplaceOptions options = new FindReplaceOptions();

    // Set a callback that tracks any replacements that the "Replace" method will make.
    TextFindAndReplacementLogger logger = new TextFindAndReplacementLogger();
    options.setReplacingCallback(logger);

    doc.getRange().replace(Pattern.compile("New York City|NYC"), "Washington", options);

    Assert.assertEquals("Our new location in (Old value:\"New York City\") Washington is opening tomorrow. " +
                    "Hope to see all our (Old value:\"NYC\") Washington-based customers at the opening!", doc.getText().trim());

    Assert.assertEquals("\"New York City\" converted to \"Washington\" 20 characters into a 21 node." +
                    "\"NYC\" converted to \"Washington\" 42 characters into a 21 node.", logger.getLog().trim());
}

/// <summary>
/// Maintains a log of every text replacement done by a find-and-replace operation
/// and notes the original matched text's value.
/// </summary>
private static class TextFindAndReplacementLogger implements IReplacingCallback {
    public int replacing(ReplacingArgs args) {
        mLog.append(MessageFormat.format("\"{0}\" converted to \"{1}\" {2} characters into a {3} node.", args.getMatch().group(0), args.getReplacement(), args.getMatchOffset(), args.getMatchNode().getNodeType()));

        args.setReplacement(MessageFormat.format("(Old value:\"{0}\") {1}", args.getMatch().group(0), args.getReplacement()));
        return ReplaceAction.REPLACE;
    }

    public String getLog() {
        return mLog.toString();
    }

    private StringBuilder mLog = new StringBuilder();
}

Example:

public void insertDocumentAtReplace() throws Exception
{
    Document mainDoc = new Document(getMyDir() + "Document insertion destination.docx");

    // We can use a "FindReplaceOptions" object to modify the find-and-replace process.
    FindReplaceOptions options = new FindReplaceOptions();
    options.setReplacingCallback(new InsertDocumentAtReplaceHandler());

    mainDoc.getRange().replace("[MY_DOCUMENT]", "", options);
    mainDoc.save(getArtifactsDir() + "InsertDocument.InsertDocumentAtReplace.docx");

}

private static class InsertDocumentAtReplaceHandler implements IReplacingCallback {
    public /*ReplaceAction*/int /*IReplacingCallback.*/replacing(ReplacingArgs args) throws Exception {
        Document subDoc = new Document(getMyDir() + "Document.docx");

        // Insert a document after the paragraph containing the matched text.
        Paragraph para = (Paragraph)args.getMatchNode().getParentNode();
        insertDocument(para, subDoc);

        // Remove the paragraph with the matched text.
        para.remove();

        return ReplaceAction.SKIP;
    }
}

/// <summary>
/// Inserts all the nodes of another document after a paragraph or table.
/// </summary>
private static void insertDocument(Node insertionDestination, Document docToInsert)
{
    if (((insertionDestination.getNodeType()) == (NodeType.PARAGRAPH)) || ((insertionDestination.getNodeType()) == (NodeType.TABLE)))
    {
        CompositeNode dstStory = insertionDestination.getParentNode();

        NodeImporter importer =
                new NodeImporter(docToInsert, insertionDestination.getDocument(), ImportFormatMode.KEEP_SOURCE_FORMATTING);

        for (Section srcSection : docToInsert.getSections())
            for (Node srcNode : srcSection.getBody())
            {
                // Skip the node if it is the last empty paragraph in a section.
                if (((srcNode.getNodeType()) == (NodeType.PARAGRAPH)))
                {
                    Paragraph para = (Paragraph)srcNode;
                    if (para.isEndOfSection() && !para.hasChildNodes())
                        continue;
                }

                // Clone the node, and insert it into the destination document.
                Node newNode = importer.importNode(srcNode, true);

                dstStory.insertAfter(newNode, insertionDestination);
                insertionDestination = newNode;
            }
    }
    else
    {
        throw new IllegalArgumentException("The destination node must be either a paragraph or table.");
    }
}