README.md 8.9 KB
Lynar Studios - Standard Library 2023.1.0
This is a cross-platform standard library written in C++ offering functionalities you would usually miss in C++'s standard template library (STL), especially if you would search for cross-platform implementations.
This library has been tested on Windows, Linux and MacOS systems.
Following a modularized approach the following independent submodules are defined in scope of this library:
Boxing
This library module provides boxing classes for primitive data types (e.g. string, int, long, float...), adding additional functionalities.
Core
The core module is a base module providing common functionalities being shared among other library submodules. Functionalities provided by this module include interfaces, exceptions and base classes, which provide basic reflection functionalities.
Encoding
To encode a byte field (e.g. a binary file) for network transfer the Base64 encoding / decoding functionality is being provided by this submodule as a first feature.
Event
This submodule comes with events in a primitive form, as well as with handlers and managers to provide an intuitive event handling for your application.
IO
To handle file operations - or to receive information of a file - this library submodule provides an own File class implementation, which can also be passed to library implemented input or output stream classes.
Additionally XML and KV parsing functionalities are provided.
Time
A Date class comes with this submodule, which you can use to represent a date and do operations on it.
Changelog
Features
- AppleClang compiler is now officially supported
- exceptions provided by core submodule now offer a constructor for passing dedicated messages
- evaluators have been added, which can check a state of variables and throw a dedicated exception in a single line and more convenient way
- a section-pair file standard has been implemented and is provided via ls-std-io module, a definition of this standard can be found in the libraries doc folder
- a base Exception class has been added, which provides basic reflection functionality - all existing library exceptions inherit from this class now
Improvements
- logic module has been removed from this library and can now be found in ls-game-tool-kit library
- core.utils module has been removed from this library to provide more clean implementations where it's needed
- the complexity of source files has been reduced by declaring usages of namespaces at the file beginning sections instead of using those in every definition implementation, this overall improves the readability of the libraries source files
- a new naming convention for files and directories has been introduced, where underscores were replaced by dashes entirely
- fetching the library version can now be achieved by using a dedicated LibraryVersion class - the usage of a static function for this purpose has been removed completely
- missing nodiscard attributes have been added to library classes
- rename "types" folder in core submodule to stick to naming convention
- key-value file standard has been removed from this library and is replaced by section-pair file standard
Fixes
- potential memory leaks have been resolved by strictly splitting prototypes and implementation project-wide, which enabled the usage of virtual or overridden destructors
- memory leaks inside exception test suite have been fixed
Documentation
You can find a detailed documentation on Lynar Studios Website: lynarstudios.com
License
This software is licensed and uses MIT-license. You can find a LICENSE.MIT file inside the project's root directory.
Building
Building this library would result into providing binaries for each library module and CLI tool:
| binary | type |
|---|---|
| cli-base64 | CLI executable |
| ls-std-boxing | library (static / dynamic) |
| ls-std-core | library (static / dynamic) |
| ls-std-encoding | library (static / dynamic) |
| ls-std-event | library (static / dynamic) |
| ls-std-io | library (static / dynamic) |
| ls-std-time | library (static / dynamic) |
Prerequisites
To build this library you'd need a supported toolchain in place, consisting of a build tool and compiler. The following table is a listing of supported compilers and build tools associated with operating systems, where this library has been tested:
| Supported Compiler (mandatory) |
OS | Supported Compiler Version (mandatory) |
Build Tool (mandatory) |
Build Tool Version (mandatory) |
|---|---|---|---|---|
| GCC | Linux Mint 20.3 | 12.2.0 | CMake | >= 3.24.0 |
| Clang | Linux Mint 20.3 | 12.0.0-3ubuntu1~20.04.5 | CMake | >= 3.24.0 |
| MinGW-w64 / GCC | Windows 10 | 11.2.0 | CMake | >= 3.24.0 |
| MSVC | Windows 10 | 19.32.31332.0 | CMake | >= 3.24.0 |
| AppleClang | MacOS Monterey | 14.0.0 | CMake | >= 3.24.0 |
Please note, that where the underlying operating system is optional in this listing, the toolchain itself is not! This means, that by default you should use one of the supported listed toolchains.
In case you'd like to use an unsupported toolchain, you can enforce this during CMake project generation. For that have a look at the CMake flag usage section below.
Generate CMake Project (Unix)
To prepare a CMake project, create a build folder within the project's root folder (where the CMakeLists.txt file is located) via CLI and navigate to it:
mkdir cmake-build-release
cd cmake-build-release
Inside this folder generate the CMake project:
cmake ../
Alternatively, the CMake project generation can be controlled by providing library specific CMake flags. The following table is a listing of available flags:
| CMake Flag | Default Value | Description |
|---|---|---|
| LS_STD_BUILD_WITH_TESTS | OFF | This flag can be enabled to build automated tests, like unit or integration tests. |
| LS_STD_BUILD_WITH_SUPPORTED_COMPILER | ON | This flag enforces the usage of supported compilers, only. For usage of an unsupported toolchain, set this flag to OFF. |
| LS_STD_BUILD_STATIC | ON | This flag indicates, that all library modules should be built as static goals. Please note, that LS_STD_BUILD_SHARED has to be turned off. |
| LS_STD_BUILD_SHARED | OFF | This flag indicates, that all library modules should be built as shared goals. Please note, that LS_STD_BUILD_STATIC has to be turned off. |
To use one or more of these flags, you'd have to adjust previous command, like:
cmake -DLS_STD_BUILD_WITH_TESTS=ON ../
Compile Project
Now, that the CMake project is generated, you should find CMake generated files inside previously created build folder. In order to compile the project run:
cmake --build . --config Release
Once compilation is done, you should find generated binaries within cmake-build-release folder.
Link ls-std Libraries (CMake)
If you would like to add this library's modules to your own CMake project, make sure that you would add the libraries' include directory:
include_directories(${CMAKE_CURRENT_LIST_DIR}/path/to/this/library/include)
Then link the libraries' binary files, like:
target_link_libraries(... ls-std-core ls-std-boxing ...)
Run Automated Tests
When enabling test build CMake flag during CMake project generation, executable test suite binaries will be generated during project compilation.
You would then find individual module test suites, as well as a whole project test suite, which can be run via CLI.