Jau Support Library (C++, Java, ...)

Original document location.

Git Repository

This project's canonical repositories is hosted on Gothel Software.

Goals

This project provides general C++ collections, algorithms and utilities.

jaulib was extracted from Direct-BT to enable general use and enforce better encapsulation, now it is utilized in multiple projects ranging from cryptography with Cipherpack, over-the-air (OTA) updates to computer graphics with Gamp.

It also provides a basic mechanisms to create a thin Java JNI binding as well as some Java JNI bindings for a subset of jaulib.

Status

Build and clang-tidy clean on C++20, passing all unit tests.

See C++ Minimum Requirements and Supported Platforms for details.

API Documentation

Up to date API documentation can be found:

• C++ API Doc with topics:
  • Basic Algorithms
  • Byte Utilities
  • C++ Language Utilities
  • Concurrency
  • Codec
  • Data Structures
  • File Utilities
  • Fraction Arithmetic and Time
  • Function Wrapper
  • IO Utilities
  • Java VM Utilities
  • Math
    • Integer types and arithmetic
    • Float types and arithmetic
    • Constant Time (CT) Operations
  • OS Support
  • Network Utilities
  • String Utilities
  • System and OS Utilities
• Java API Doc.

Examples

See Direct-BT C++ API Doc.

Usage

• Direct-BT
• Cipherpack
• Gamp

C++ Minimum Requirements

C++20 is the minimum requirement for releases > 1.2.0.

Release 1.2.0 is the last version supporting C++17, see Changes.

Support for C++23 and C++26 will be added step by step.

Optional WebAssembly (Wasm) builds via emscripten.

C++ Compiler Support

• C++20, see C++20 compiler support
  • gcc >= 11, recommended >= 12.2.0
  • clang >= 13, recommended >= 18.1.6

Rational for C++20 Minimum

• Moving metaprogramming to C++20 concepts and constrains
  • SFINAE and its utilization in type_traits for C++ metaprogramming are great
  • C++20 constrains add an easier to read and code alternative using the same idea
  • C++20 concepts declare a set of C++20 constrains and can be reused, guarantees of same concept
  • C++ Named Requirements are defined as concepts next to type traits counterpart
  • Hence moving step by step to C++20 concepts helps with maintainability
• Lack of C++17 constexpr completeness in the STL (e.g. std::string)
• Used compiler gcc and clang have matured enough for C++20 in 2024

Supported Platforms

Language requirements

• C++20 or better, see C++ Minimum Requirements
• Standard C Libraries
  • FreeBSD libc
  • GNU glibc
  • musl
• emscripten >= 3.1.59 optional for WebAssembly (Wasm)
• Java 11, 17+ (optional)

See supported platforms for details.

Building Binaries

It is advised to include this library into your main project, e.g. as a git-submodule.

Then add jaulib/include/ to your C++ include-path and also add the C++ source files under jaulib/src/ into your build recipe.

The produced Java libraries are fully functional.

This library's build recipe are functional though, but currently only intended to support unit testing and to produce a Doxygen API doc.

Build Dependencies

• CMake >= 3.21 (2021-07-14)
• C++ compiler
  • gcc >= 11 (C++20), recommended >= 12.2.0
  • clang >= 13 (C++20), recommended >= 18.1.6
• Optional for lint validation
  • clang-tidy >= 19
• Optional for eclipse and vscodium integration
  • clangd >= 19
  • clang-tools >= 19
  • clang-format >= 19
• Optional
  • libunwind8 >= 1.2.1
  • libcurl4 >= 7.74 (tested, lower may work)
• Optional Java support
  • OpenJDK >= 11
  • junit4 >= 4.12

Install on FreeBSD

Installing build dependencies on FreeBSD >= 13:

pkg install git
pkg install sudo
pkg install cmake
pkg install libunwind
pkg install doxygen
pkg install squashfs-tools
pkg install bash
ln -s /usr/local/bin/bash /bin/bash

Install optional Java dependencies:

pkg install openjdk17
pkg install openjdk17-jre
pkg install junit
rehash

For Java ensure /etc/fstab includes:

fdesc   /dev/fd         fdescfs         rw      0       0
proc    /proc           procfs          rw      0       0

jau::fs::mount_image() and jau::fs::umount() are currenly not fully implemented under FreeBSD, hence testing using cmake option -DTEST_WITH_SUDO=ON is disabled.

To use URL streaming functionality via the curl library in jau_io_util.hpp and jau/io_util.cpp, the cmake option -DUSE_LIBCURL=ON must be set.
This also requires installation of the following packets:

pkg install curl
apt install mini-httpd

Note: mini-httpd is being used for unit testing URL streaming only.

Install on Debian or Ubuntu

Installing build dependencies on Debian >= 11 and Ubuntu >= 20.04:

apt install git
apt install build-essential g++ gcc libc-dev libpthread-stubs0-dev
apt install clang-19 clang-tidy-19 clangd-19 clang-tools-19 clang-format-19
apt install libunwind8 libunwind-dev
apt install cmake cmake-extras extra-cmake-modules
apt install doxygen graphviz

If using the optional clang toolchain, perhaps change the clang version-suffix of above clang install line to the appropriate version.

After complete clang installation, you might want to setup the latest version as your default. For Debian you can use this clang alternatives setup script.

Install optional Java dependencies:

apt install openjdk-17-jdk openjdk-17-jre junit4

To test jau::fs::mount_image() and jau::fs::umount() under Linux with enabled cmake option -DTEST_WITH_SUDO=ON,
the following build dependencies are added

apt install libcap-dev libcap2-bin
apt install squashfs-tools

To use URL streaming functionality via the curl library in jau_io_util.hpp and jau/io_util.cpp, the cmake option -DUSE_LIBCURL=ON must be set.
This also requires installation of the following packets:

apt install libcurl4 libcurl4-gnutls-dev
apt install mini-httpd

Note: mini-httpd is being used for unit testing URL streaming only.

WebAssembly (via emscripten)

At time of writing (Debian 12), it is recommended to install emscripten >= 3.1.59 for WebAssembly (Wasm) from its upstream source.

At a later time (more recent Debian > 12 deployment) the Debian default may be functional:

apt install emscripten

Build Procedure

Build preparations

git clone https://jausoft.com/cgit/jaulib.git
cd jaulib

CMake Build via Presets

Following debug presets are defined in CMakePresets.json

• debug
  • default generator
  • default compiler
  • C++20
  • debug enabled
  • disabled clang-tidy
  • java (if available)
  • libunwind (if available)
  • libcurl (if available)
  • testing on
  • testing with sudo off
  • binary-dir build/debug
  • install-dir dist/debug
• debug-clang
  • inherits from debug
  • compiler: clang
  • enabled clang-tidy
  • binary-dir build/debug-clang
  • install-dir dist/debug-clang
• debug-gcc
  • inherits from debug
  • compiler: gcc
  • disabled clang-tidy
  • binary-dir build/debug-gcc
  • install-dir dist/debug-gcc
• release
  • inherits from debug
  • debug disabled
  • disabled clang-tidy
  • testing with sudo on
  • binary-dir build/release
  • install-dir dist/release
• release-clang
  • compiler: clang
  • enabled clang-tidy
  • binary-dir build/release-clang
  • install-dir dist/release-clang
• release-gcc
  • compiler: gcc
  • disabled clang-tidy
  • binary-dir build/release-gcc
  • install-dir dist/release-gcc
• default
  • inherits from debug-clang
  • binary-dir build/default
  • install-dir dist/default

Kick-off the workflow by e.g. using preset release-gcc to configure, build, test, install and building documentation. You may skip install and doc_jau by dropping it from --target.

cmake --preset release-gcc
cmake --build --preset release-gcc --parallel
cmake --build --preset release-gcc --target test install doc_jau

You may utilize scripts/build-preset.sh for an initial build, install and test workflow.

CMake Build via Hardcoded Presets

Besides above CMakePresets.json presets, JaulibSetup.cmake contains hardcoded presets for undefined variables if

• CMAKE_INSTALL_PREFIX and CMAKE_CXX_CLANG_TIDY cmake variables are unset, or
• JAU_CMAKE_ENFORCE_PRESETS cmake- or environment-variable is set to TRUE or ON

The hardcoded presets resemble debug-clang presets.

Kick-off the workflow to configure, build, test, install and building documentation. You may skip install and doc_jau by dropping it from --target.

rm -rf build/default
cmake -B build/default
cmake --build build/default --parallel
cmake --build build/default --target test install doc_jau

The install target of the last command will create the include/ and lib/ directories with a copy of the headers and library objects respectively in your dist location.

CMake Variables

Our cmake configure has a number of options, cmake-gui or ccmake can show you all the options. The interesting ones are detailed below:

JaulibPreset cached variables for hardcoded presets are

• CMAKE_BUILD_TYPE
• BUILD_TESTING
• CMAKE_C_COMPILER
• CMAKE_CXX_COMPILER
• CMAKE_CXX_CLANG_TIDY
• CMAKE_CXX_STANDARD

JaulibSetup cached variables for regular builds are

• DEBUG
• CMAKE_INSTALL_PREFIX
• CMAKE_CXX_STANDARD
• USE_LIBCURL
• USE_LIBUNWIND
• BUILDJAVA

Changing install path

-DCMAKE_INSTALL_PREFIX=/somewhere/dist-jaulib

Building debug build:

-DDEBUG=ON

or

-DCMAKE_BUILD_TYPE=Debug

Enable/disable unit tests to build

-DBUILD_TESTING=ON

Add unit tests requiring sudo to build (default: disabled).
This option requires -DBUILD_TESTING=ON to be effective.
Covered unit test requiring sudo are currently

• Linux OS
  • jau::fs::mount_image()
  • jau::fs::umount()

    -DTEST_WITH_SUDO=ON

Using clang instead of gcc:

-DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++

Building with clang and clang-tidy lint validation

-DCMAKE_C_COMPILER=/usr/bin/clang
-DCMAKE_CXX_COMPILER=/usr/bin/clang++
-DCMAKE_CXX_CLANG_TIDY=/usr/bin/clang-tidy;-p;$rootdir/$build_dir

Disable stripping native lib even in non debug build:

-DUSE_STRIP=OFF

Enable using libcurl (default: disabled)

-DUSE_LIBCURL=ON

Enable using libunwind (default: disabled)

-DUSE_LIBUNWIND=ON

Disable using C++ Runtime Type Information (RTTI) (default: enabled)

-DDONT_USE_RTTI=ON

Building debug and instrumentation (sanitizer) build:

-DDEBUG=ON -DINSTRUMENTATION=ON

Cross-compiling on a different system:

-DCMAKE_CXX_FLAGS:STRING=-m32 -march=i586
-DCMAKE_C_FLAGS:STRING=-m32 -march=i586

To build documentation run:

make doc

To build Java bindings:

-DBUILDJAVA=ON

Override default javac debug arguments source,lines:

-DJAVAC_DEBUG_ARGS="source,lines,vars"
 
-DJAVAC_DEBUG_ARGS="none"

Build Scripts

Build scripts use the recommended cmake presets, supported via e.g. scripts/build-preset.sh.

• scripts/setup-machine-arch.sh .. generic setup for all scripts
• scripts/setup-emscripten.sh .. emscripten setup
• scripts/build-preset.sh .. initial build incl. install and unit testing using presets
• scripts/rebuild-preset.sh .. rebuild using presets
• scripts/build-preset-cross.sh .. cross-build using presets
• scripts/rebuild-preset-cross.sh .. cross-build using presets
• scripts/test_java.sh .. invoke a java unit test
• scripts/test_exe_template.sh .. invoke the symlink'ed files to invoke native unit tests

Cross Build

Also provided is a cross-build script using chroot into a target system using QEMU User space emulation and Linux kernel binfmt_misc to run on other architectures than the host.

See Build Procedure for general overview.

You may use our pi-gen branch to produce a Raspi-arm64, Raspi-armhf or PC-amd64 target image.

IDE Integration

Eclipse

Tested Eclipse 2024-03 (4.31).

IDE integration configuration files are provided for

• Eclipse with extensions
  • CDT or CDT @ eclipse.org
  • CDT-LSP recommended
    • Should work with clang toolchain >= 16
    • Utilizes clangd, clang-tidy and clang-format to support C++20 and above
    • Add to available software site: https://download.eclipse.org/tools/cdt/releases/cdt-lsp-latest
    • Install C/C++ LSP Support in the Eclipse CDT LSP Category
  • CMake Support, install C/C++ CMake Build Support with ID org.eclipse.cdt.cmake.feature.group
    • Usable via via Hardcoded CMake Presets with debug-clang

The Hardcoded CMake Presets will use build/default as the default build folder with debug enabled.

Make sure to set the environment variable CMAKE_BUILD_PARALLEL_LEVEL to a suitable high number, best to your CPU core count. This will enable parallel build with the IDE.

You can import the project to your workspace via File . Import... and Existing Projects into Workspace menu item.

For Eclipse one might need to adjust some setting in the .project and .cproject (CDT) via Eclipse settings UI, but it should just work out of the box.

Otherwise recreate the Eclipse project by

• delete .project and .cproject
• File . New . C/C++ Project and Empty or Existing CMake Project while using this project folder.

VSCodium or VS Code

IDE integration configuration files are provided for

• VSCodium or VS Code with extensions
  • vscode-clangd
  • twxs.cmake
  • ms-vscode.cmake-tools
  • notskm.clang-tidy
  • Java Support
    • redhat.java
      • Notable, .settings/org.eclipse.jdt.core.prefs describes the lint behavior
    • vscjava.vscode-java-test
    • vscjava.vscode-java-debug
    • vscjava.vscode-maven
  • cschlosser.doxdocgen
  • jerrygoyal.shortcut-menu-bar

For VSCodium one might copy the example root-workspace file to the parent folder of this project (note the filename change) and adjust the path to your filesystem.

cp .vscode/jaulib.code-workspace_example ../jaulib.code-workspace
vi ../jaulib.code-workspace

Then you can open it via File . Open Workspace from File... menu item.

• All listed extensions are referenced in this workspace file to be installed via the IDE
• Select one of the CMake Presets for
  • Configuration
  • Build
  • Test

Changes

See Changes.