libE57Format

libE57Format requires the Xerces-C++ library for XML parsing. Depending on your operating system, use the following commands to install the necessary dependencies:

Ubuntu/Linux: Install libxerces-c-dev and clang-format via apt.

macOS: Install ccache, clang-format, and xerces-c via homebrew.

# Ubuntu
$ sudo apt install libxerces-c-dev clang-format

# macOS
$ brew install ccache clang-format xerces-c

CRC++ is a header-only library. To use it in your project, you do not need to compile a library or manage complex build settings. Simply include the CRC.h header file in your C++ source code. It is compatible with any reasonably compliant C++03 or C++11 compiler, though C++11 is recommended for better compile-time performance.

#include "CRC.h"

While CRC++ is header-only and requires no build for basic usage, you can use CMake to build the included unit tests and Doxygen documentation.

mkdir -p build
cd build
cmake .. [-DBUILD_DOC=ON]

# Build and run unit tests
make tests

# Build documentation (requires Doxygen)
make doxygen

# Install the header file
sudo make install

If your input data is not a multiple of CHAR_BIT (usually 8 bits), use CRC::CalculateBits(). The second argument specifies the exact number of bits to process. Note that the input data buffer must still be a whole number of bytes; any unused bits in the final byte should be padded with zeros.

const unsigned char data[] = { 0x98, 0x76, 0x54, 0x32, 0x10 };
// Compute CRC for exactly 37 bits
std::uint32_t crc = CRC::CalculateBits(data, 37, CRC::CRC_32());

You can compute a CRC over multiple non-contiguous buffers by passing the result of the previous calculation as the final argument to the next CRC::Calculate call. This allows you to chain data segments together.

std::uint32_t crc;
// First part
crc = CRC::Calculate(part1, size1, CRC::CRC_32());
// Second part (chains onto the first)
crc = CRC::Calculate(part2, size2, CRC::CRC_32(), crc);

To compute a CRC, use the CRC::Calculate function. You must provide the data buffer, the size of the buffer, and a CRC definition (e.g., CRC::CRC_32()).

#include "CRC.h"
#include <cstdint>

int main() {
    const char myString[] = { 'H', 'E', 'L', 'L', 'O' };
    std::uint32_t crc = CRC::Calculate(myString, sizeof(myString), CRC::CRC_32());
    return 0;
}

For high-performance requirements, use CRC::Table. Lookup tables are significantly faster than bit-by-bit calculation but consume more memory. A table can be reused for multiple calculations as long as it remains in scope.

// Option 1: Explicitly define the table type
CRC::Table<std::uint32_t, 32> table(CRC::CRC_32());
std::uint32_t crc = CRC::Calculate(data, size, table);

// Option 2: Use the auto keyword with MakeTable()
auto table = CRC::CRC_32().MakeTable();
std::uint32_t crc = CRC::Calculate(data, size, table);

To build libE57Format, your environment must meet the following requirements:

• A C++14 compatible compiler.
• CMake version 3.15 or higher.
• clang-format (for code formatting).
• Xerces-C++ (dependency for XML parsing).
• (Optional) ccache to accelerate rebuilds.