Can APDFL and Modern C++ Run in the Same Program?

Overview

Yes. The Adobe PDF Library (APDFL) Adobe C/C++ interface and the Modern C++ interface can be used in the same application. Datalogics Engineering has confirmed that this use is expected to work. This allows applications to retain existing Adobe C/C++ workflows while introducing Modern C++ for new or migrated functionality.

Using both interfaces together does not provide direct object interoperability. Objects created through one interface are not automatically available through the other. To transfer document content between interfaces, save the document and reopen it through the other interface.

The investigation described below was performed on Windows x64 only, using Modern C++ SDK 21.5.0 and APDFL 21.0.0P1f. Other platforms and toolchains were not tested.

What Did the Investigation Demonstrate?

The test program successfully used both interfaces with either initialization order, with documents open through both interfaces at the same time, and with calls interleaved between them.

The investigation reported twelve successful runs covering six execution modes and two header inclusion orders:

• Both interfaces worked independently as baseline tests.
• Including the Modern C++ headers before or after the Adobe C/C++ headers compiled successfully.
• Initializing either interface first allowed both interfaces to operate.
• Destroying the Modern C++ Library left an existing legacy PDDoc usable.
• Calling PDFLTermHFT() left an existing Modern C++ document usable while its Library remained active.
• Legacy operations on the main thread and Modern C++ operations on a worker thread completed 200 iterations each using separate documents.

These tests covered the configurations and operations described in this article. The observed initialization and termination behavior should not be treated as a guarantee for every configuration.

Why Do the Interfaces Coexist?

The Modern C++ interface provides an object-oriented interface to the same underlying APDFL engine used by Adobe C/C++. It does not introduce a separate PDF engine.

In the tested Windows configuration, datalogics_interface_api.dll depends on DL210pdfl.dll. The legacy application also accesses that core library through its Host Function Table (HFT) initialization.

Each interface maintains its own client-side initialization state while accessing the shared core. The investigation attributed the successful teardown tests to reference-counted initialization, allowing the core to remain available while the other interface still required it.

Applications should continue to balance initialization and termination and release each interface’s documents before terminating that interface.

What Can Be Shared Between the Interfaces?

The interfaces can operate in the same process, but they do not currently provide direct interoperability between their API objects.

For example, creating an annotation through Modern C++ does not provide a corresponding Adobe C/C++ object handle that the application can immediately use. Likewise, the tested Modern C++ public API does not expose or accept legacy PDDoc, CosDoc, or CosObj handles.

To work with the resulting content through the other interface:

1. Save the document using the interface that modified it.
2. Open the saved document through the other interface.
3. Access the content using that interface’s API.

A file provides a straightforward transfer method. Memory-based serialization can also avoid a temporary file when implemented using the appropriate APIs on both sides.

Set Up the Test Program on Windows

The complete mixtest.cpp uses both SDK interfaces in one C++ executable. It is not intended to build against either SDK alone.

The investigation used the following configuration:

set "APDFL=C:\Datalogics\APDFL21.0.0P1f_x64"
set "MCPP=C:\Datalogics\ModernCppSDK-21.5.0"

cl /nologo /EHsc /MD /std:c++17 /Fe:mixtest.exe ^
   /D_CRT_SECURE_NO_WARNINGS /D_CONSOLE /DWIN64 /DWIN_ENV /DWIN_PLATFORM ^
   /DPRODUCT=\"HFTLibrary.h\" ^
   /DPI_ACROCOLOR_VERSION=AcroColorHFT_VERSION_6 ^
   /I"%APDFL%\CPlusPlus\Include\Headers" /I"%MCPP%\include" ^
   mixtest.cpp ^
   "%APDFL%\CPlusPlus\Include\Source\PDFLInitCommon.c" ^
   "%APDFL%\CPlusPlus\Include\Source\PDFLInitHFT.c" ^
   /link ^
   /LIBPATH:"%APDFL%\CPlusPlus\Binaries" ^
   /LIBPATH:"%MCPP%\lib" ^
   DL210PDFL.lib datalogics_interface_api.lib

set "PATH=%MCPP%\lib;%PATH%"

mixtest.exe legacy
mixtest.exe modern
mixtest.exe legacy-first
mixtest.exe modern-first
mixtest.exe threads
mixtest.exe longjmp

#include "PDFLCalls.h"
#include "ASCalls.h"
#include "PDCalls.h"
#include "CosCalls.h"
#include <datalogics_interface/datalogics_interface.hpp>

#include <exception>
#include <iostream>

namespace dl = datalogics_interface;

int main()
{
    if (legacy_init() != 0)
        return 1;

    legacy_open();
    int result = 0;

    try
    {
        dl::Library library;
        dl::Document document(kPdf);

        std::cout << "Modern C++ pages: "
                  << document.get_num_pages() << '\n';

        legacy_use("while-modern-live");

        std::cout << "Modern C++ pages after legacy call: "
                  << document.get_num_pages() << '\n';
    }
    catch (const std::exception& error)
    {
        std::cerr << error.what() << '\n';
        result = 1;
    }

    // Modern C++ objects have left scope.
    // The legacy document remains available.
    legacy_use("after-modern-teardown");

    legacy_close();
    legacy_term();
    return result;
}