progressCallback example?

[gbook]

Is there an example on how to use the progress callback from BitArchiveWriter, BitArchiveEditor, and BitArchiveReader?

[rikyoz]

Hi!
There are some descriptions of the callbacks here, but I still have to put some more details and examples in the wiki, sorry.

Anyway, the progress callback is a std::function that reports the number of bytes that have been processed by the current ongoing operation. It can be a lambda, a free/member function, etc.

Usually, it is used together with the total callback to calculate, for example, the current progress percentage:

std::uint64_t totalSize = 0;
writer.setTotalCallback([&]( std::uint64_t total ) {
    totalSize = total;
});

writer.setProgressCallback([&total]( std::uint64_t progress ) -> bool {
    const auto percentage = static_cast<int>(
                                100.0 * (static_cast<double>(progress) / static_cast<double>(total))
                            );
    std::cout << "Compression progress: " << percentage << "%" << std::endl;
    return true;
});

Please note that 7-Zip callbacks are blocking, so if you do some heavy operations in the body of the callback, it might slow down the compression (or extraction) operation.
In a Qt application I developed some time ago, the progress callback emitted a signal with the calculated percentage, and the signal set the value of a QProgressBar, instead of setting it directly within the callback.

[gbook]

This is very helpful, thank you!

I was able to get callbacks to work, using global function(s) and variables. I realized I actually need to call a member function which is part of the same object as the calling object... It seems conceptually easy, but apparently implementation is not so easy. Do you have an example of calling a member function through the callback, or do you have your Qt signals/slots example?

[rikyoz]

an example of calling a member function through the callback

Using a lambda or std::bind you should be able to directly use a member function as the callback. Just a dummy example:

class Compressor {
        std::uint64_t mTotal;
        const Bit7zLibrary& mLib;
    public:
        explicit Compressor( const Bit7zLibrary& lib ) : mLib{ lib } {}

        void setTotal( std::uint64_t total ) {
            mTotal = total;
        }

        [[nodiscard]]
        auto printProgress( std::uint64_t progress ) const -> bool {
            const auto percentage = static_cast<int>(
                100.0 * (static_cast<double>(progress) / static_cast<double>(mTotal))
            );
            std::cout << "Compression progress: " << percentage << "%" << std::endl;
            return true;
        }

        void compress( const std::string& dir, const std::string& arc ) {
            BitArchiveWriter writer{ mLib, BitFormat::SevenZip };
            writer.setOverwriteMode( OverwriteMode::Overwrite );
            writer.setTotalCallback( std::bind( &Compressor::setTotal, this, std::placeholders::_1 ) );
            writer.setProgressCallback( std::bind( &Compressor::printProgress, this, std::placeholders::_1 ) );
            writer.addFiles( dir );
            writer.compressTo( arc );
        }
};

do you have your Qt signals/slots example?

Unfortunately, I cannot seem to find the source of the Qt application I mentioned before, but if I remember correctly, the idea was this:

• Create a class extending QThread, and declaring some signals (one for each callback); the responsibility of this class is to:
  • Create the bit7z writer/compressor or reader/extractor object, storing it in a member variable.
  • Set its callbacks to emit their correspondent signal.
  • Run the compression/extraction operation using bit7z (in the QThread::run).
    • All this is needed as such operations would block the UI otherwise, of course.
• On the UI thread, the MainWindow would create the thread object and connect to the signals of the thread object, assigning the corresponding slots.
  • In the slots, you would update the UI with the data provided by the signals (e.g., set the progress value of a QProgressBar).

[gbook]

Very helpful, thank you!