README.md


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205


    Contents⊕
  
  
  Jau Support Library (C++,
  Java, ...)
  
  Git Repository
  Goals
  API Documentation
  Examples
  Supported Platforms
  Building Binaries
  
  Build Dependencies
  Cross Build
  
  Changes
  
  
Jau Support Library (C++, Java,
...)
Original
document location.
Git Repository
This project's canonical repositories is hosted on Gothel Software.
Goals
This project aims to provide general C++ and Java collections,
algorithms and utilities - as well as basic concepts to support a Java
JNI binding.
This project was extracted from Direct-BT to
enable general use and enforce better encapsulation.
API Documentation
Up to date API documentation can be found:

C++
API Doc with modules:

Basic
Algorithms
Byte
Utilities
C++
Language Utilities
Concurrency
Data
Structures
File
Utilities
Float
types and arithmetic
Fraction
Arithmetic and Time
Function
Pointer
Integer
types and arithmetic
IO
Utilities
Java
VM Utilities
Network
Utilities
String
Utilities
System
and OS Utilities

Java
API Doc.

Examples
See Direct-BT C++
API Doc.
Supported Platforms
Minimum language requirements

C++17
Java 11 (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.13+ but >= 3.18 is recommended
gcc >= 8.3.0

or clang >= 10.0

Optional

libunwind8 >= 1.2.1
libcurl4 >= 7.74 (tested, lower may work)
For Java support

OpenJDK >= 11
junit4 >= 4.12


The project requires CMake 3.13+ for building and a Java JDK >=
11.
Installing build dependencies for Debian >= 11 and Ubuntu >=
20.04:
apt install git
apt install build-essential g++ gcc libc-dev libpthread-stubs0-dev 
apt install libunwind8 libunwind-dev
apt install openjdk-17-jdk openjdk-17-jre junit4
apt install cmake cmake-extras extra-cmake-modules
apt install doxygen graphviz
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.
For a generic build use:
CPU_COUNT=`getconf _NPROCESSORS_ONLN`
git clone https://jausoft.com/cgit/jaulib.git
cd jaulib
mkdir build
cd build
cmake -DBUILDJAVA=ON -DBUILDEXAMPLES=ON -DBUILD_TESTING=ON ..
make -j $CPU_COUNT install test doc
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 build location. Note that doing an out-of-source
build may cause issues when rebuilding later on.
Our cmake configure has a number of options, cmake-gui or
ccmake can show you all the options. The interesting ones are
detailed below:
Changing install path from /usr/local to /usr
-DCMAKE_INSTALL_PREFIX=/usr
Building debug build:
-DDEBUG=ON
Add unit tests to build (default: disabled)
-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
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
Override default javac debug arguments source,lines:
-DJAVAC_DEBUG_ARGS="source,lines,vars"

-DJAVAC_DEBUG_ARGS="none"
Building debug and instrumentation (sanitizer) build:
-DDEBUG=ON -DINSTRUMENTATION=ON
Using clang instead of gcc:
-DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++
Cross-compiling on a different system:
-DCMAKE_CXX_FLAGS:STRING=-m32 -march=i586
-DCMAKE_C_FLAGS:STRING=-m32 -march=i586
To build Java bindings:
-DBUILDJAVA=ON
To build documentation run:
make doc
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.
You may use our
pi-gen branch to produce a Raspi-arm64, Raspi-armhf or PC-amd64
target image.
Changes
See Changes.