This project's canonical repositories is hosted on Gothel Software.
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.
Build and clang-tidy (23.1.0) clean on C++20 and C++23, passing all unit tests.
See C++ Requirements and Supported Platforms for details.
Up to date API documentation can be found:
-
C++ API Doc with topics:
See Direct-BT C++ API Doc.
C++20 is the minimum requirement for releases > 1.2.0.
C++23 is the default for relases > 1.8.2, while C++20 is still supported.
Release 1.2.0 is the last version supporting C++17, see Changes.
Support for C++26 will be added step by step.
Optional WebAssembly (Wasm) builds via emscripten.
See details in C++ Support.
-
C++23, see C++23 compiler support
- gcc >= 14, recommended >= 14.2.0
- clang >= 19, recommended >= 23.1.0
- Satisfied by
- FreeBSD 14.3 and above
- Debian 13 'Trixie' and above
- Ubuntu 24.04 LTS
Noble Numbatand above
-
C++20, see C++20 compiler support
- gcc >= 11, recommended >= 14.2.0
- clang >= 13, recommended >= 23.1.0
- Satisfied by
- FreeBSD 14.3 and above
- Debian 12 'Bookworm' and above
- Ubuntu 22.04 LTS
Jammy Jellyfishand above
- New C++20 Features
- Moving metaprogramming to C++20 concepts and constrains
SFINAEand its utilization intype_traitsfor 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
C++ Named Requirementsare defined as concepts next totype traitscounterpart- Hence moving step by step to C++20 concepts helps with maintainability
- Lack of C++17
constexprcompleteness in theSTL(e.g.std::string) - Used compiler
gccandclanghave matured enough for C++20 in 2024
- New C++23 Features
- Potential positive performance impact
- Simplified implicit move or copy-elision
- Widened
constexprfunction constraints
- Readability/Usability
- It has been almost 3 years and compiler caught up in 2026
- Preparation for the bigger C++26 update
Language requirements
- C++20 or better, see C++ Requirements
- Standard C Libraries
- emscripten >= 7.0.0 optional for WebAssembly (Wasm)
- wasmtime for unit tests
- Java 11, 21
See supported platforms for details.
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.
- CMake >= 3.21 (2021-07-14)
- C++ compiler
- gcc >= 11 (C++20), recommended >= 14.2.0
- clang >= 13 (C++20), recommended >= 23.1.0
- Optional for
lintvalidation- clang-tidy >= 19
- Optional for
eclipseandvscodiumintegration- 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
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 openjdk21
pkg install openjdk21-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
pkg install mini-httpd
Note: mini-httpd is being used for unit testing URL streaming only.
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-23 clang-tidy-23 clangd-23 clang-tools-23 clang-format-23
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. Find more current clang version for Debian/Ubuntu.
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-21-jdk openjdk-21-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.
At time of writing (Debian 13), it is recommended to install emscripten >= 7.0.0 for WebAssembly (Wasm) from its upstream source.
# Start from home directory
cd $HOME
# Get the emsdk repo
git clone https://github.com/emscripten-core/emsdk.git
# Enter that directory
cd emsdk
# Fetch the latest version of the emsdk (not needed the first time you clone)
git pull
# Download and install the latest SDK tools.
./emsdk install latest
# Make the "latest" SDK "active" for the current user. (writes .emscripten file)
./emsdk activate latest
# Activate PATH and other environment variables in the current terminal
source ./emsdk_env.sh
At a later time (more recent Debian > 13 deployment) the Debian default may be functional:
apt install emscripten
git clone https://jausoft.com/cgit/jaulib.git
cd jaulib
Following debug presets are defined in CMakePresets.json
debug- default generator
- default compiler
- C++23
- LTO for all targets disabled
- 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- compiler:
clang - enabled
clang-tidy - binary-dir
build/debug-clang - install-dir
dist/debug-clang
- compiler:
debug-gcc- compiler:
gcc - disabled
clang-tidy - binary-dir
build/debug-gcc - install-dir
dist/debug-gcc default- binary-dir
build/default - install-dir
dist/default
- binary-dir
- compiler:
release- LTO for all targets enabled
- debug disabled (strip libraries)
- 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
- compiler:
release-gcc- compiler:
gcc - disabled
clang-tidy - binary-dir
build/release-gcc - install-dir
dist/release-gcc
- compiler:
perf-clang- debug disabled
- no strip
- compiler:
clang - disabled
clang-tidy - binary-dir
build/perf-clang - install-dir
dist/perf-clang
perf-gcc- debug disabled
- no strip
- compiler:
gcc - disabled
clang-tidy - binary-dir
build/perf-gcc - install-dir
dist/perf-gcc
docker- default generator
- compiler:
gcc - disabled
clang-tidy - C++23
- LTO for all targets enabled
- debug disabled
- java enabled
- libunwind (if available)
- libcurl (if available)
- testing on
- testing with sudo off
- binary-dir
build/docker - install-dir
dist/docker
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.
Besides above CMakePresets.json presets,
JaulibSetup.cmake contains hardcoded presets for undefined variables if
CMAKE_INSTALL_PREFIXandCMAKE_CXX_CLANG_TIDYcmake variables are unset, orJAU_CMAKE_ENFORCE_PRESETScmake- or environment-variable is set toTRUEorON
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.
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_TYPEBUILD_TESTINGCMAKE_C_COMPILERCMAKE_CXX_COMPILERCMAKE_CXX_CLANG_TIDYCMAKE_CXX_STANDARD
JaulibSetup cached variables for regular builds are
DEBUGCMAKE_INSTALL_PREFIXCMAKE_CXX_STANDARDUSE_LIBCURLUSE_LIBUNWINDBUILDJAVAUSE_LTO_FOR_ALL_TARGETSTOOLCHAIN_SUPPORTS_IPO
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
LinuxOSjau::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
Enable LTO for all targets (default: enabled for release)
If TOOLCHAIN_SUPPORTS_IPO is enabled via cmake detection,
all targets will be build with LTO support
by enabling the cmake variable CMAKE_INTERPROCEDURAL_OPTIMIZATION.
-DUSE_LTO_FOR_ALL_TARGETS=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 use the recommended cmake presets,
supported via e.g. scripts/build-preset.sh.
scripts/setup-machine-arch.sh.. generic setup for all scriptsscripts/setup-emscripten.sh.. emscripten setupscripts/build-preset.sh.. initial build incl. install and unit testing using presetsscripts/rebuild-preset.sh.. rebuild using presetsscripts/build-preset-cross.sh.. cross-build using presetsscripts/rebuild-preset-cross.sh.. cross-build using presetsscripts/build-docker-fatjar-multiarch.sh.. docker-cross-buildscripts/test_java.sh.. invoke a java unit testscripts/test_exe_template.sh.. invoke the symlink'ed files to invoke native unit tests
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.
Docker allows cross-platform builds via qemu binfmt
w/o the hassle to maintain system images ourselves as described above.
Find instructions to setup a rootless Docker on Debian13,
i.e. secure w/o sudo root access.
For best security separation, consider using a dedicated docker-dev user to perform all docker related procedures
within the rootless docker environment.
To test the build configuration upfront, the cmake-preset docker can be used in a host build,
using same cmake settings.
Launch docker script:
scripts/build-docker-fatjar-multiarch.sh [--rebuild] [--notesting] [--platforms "linux/amd64,linux/arm64/v8,linux/arm/v7"] [--out DIR]
- Pass
--rebuildto keep previous build artifacts, used in development - Pass
--notestingto skip building and performing unit tests - Optionally pass one or a comma-separated set of platforms via
--platforms
The following steps kick-off a fresh Docker build
# one-time: register qemu binfmt for foreign-arch containers
docker run --privileged --rm tonistiigi/binfmt --install arm64,arm
scripts/build-docker-fatjar-multiarch.sh
java -jar build-docker/fatjar/jaulib-fat.jar
It builds each architecture in a Debian container under that platform (docker + qemu) and merges the
per-arch natives into a single fat jar at build-docker/fatjar/jaulib-fat.jar. This replaces the
mounted-rootfs cross build in scripts/build-preset-cross.sh, which needs private disk images. Default
architectures are linux/amd64 + linux/arm64/v8 + linux/arm/v7.
Finally it performs a quick bring-up test w/ Java on the host platform,
which should succeed if the host architecture was included in the --platforms list.
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 Supportin theEclipse CDT LSP Category
CMake Support, installC/C++ CMake Build Supportwith IDorg.eclipse.cdt.cmake.feature.group- Usable via via Hardcoded CMake Presets with
debug-clang
- Usable via via Hardcoded CMake Presets with
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
.projectand.cproject File . New . C/C++ ProjectandEmpty or Existing CMake Projectwhile using this project folder.
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.prefsdescribes thelintbehavior
- Notable,
- vscjava.vscode-java-test
- vscjava.vscode-java-debug
- vscjava.vscode-maven
- redhat.java
- 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
See Changes.