beman.cstringview: cstringview, a null-terminated string view

beman.cstring_view is a header-only cstring_view library.

Implements: std::cstring_view proposed in cstring_view (P3655R2).

Status: Under development and not yet ready for production use.

Usage

std::cstring_view exposes a string_view like type that is intended for being able to propagate prior knowledge that a string is null-terminated throughout the type system, while fulfilling the same role as string_view.

Usage: default projection in constrained algorithms

The following code snippet illustrates how we can use cstring_view to make a beginner-friendly main:

```cpp

include

include

int main(int argc, const char** argv) { std::vector args(argv, argv+argc); } ```

Full runnable examples can be found in examples/.

Dependencies

Build Environment

This project requires at least the following to build:

• C++17
• CMake 3.25
• (Test Only) GoogleTest

You can disable building tests by setting cmake option BEMAN_CSTRING_VIEW_BUILD_TESTS to OFF when configuring the project.

Supported Platforms

This project officially supports:

• GNU GCC Compiler [version 12-14]
• LLVM Clang++ Compiler [version 17-20]
• AppleClang compiler on Mac OS
• MSVC compiler on Windows

[!NOTE]

Versions outside of this range would likely work as well, especially if you're using a version above the given range (e.g. HEAD/ nightly). These development environments are verified using our CI configuration.

Development

Develop using GitHub Codespace

This project supports GitHub Codespace via Development Containers, which allows rapid development and instant hacking in your browser. We recommend you using GitHub codespace to explore this project as this requires minimal setup.

You can create a codespace for this project by clicking this badge:

For more detailed documentation regarding creating and developing inside of GitHub codespaces, please reference this doc.

[!NOTE]

The codespace container may take up to 5 minutes to build and spin-up, this is normal as we need to build a custom docker container to setup an environment appropriate for beman projects.

Develop locally on your machines

For Linux based systems

Beman libraries require [recent versions of CMake](#build-environment), we advise you to download CMake directly from [CMake's website](https://cmake.org/download/) or install it via the [Kitware apt library](https://apt.kitware.com/). A [supported compiler](#supported-platforms) should be available from your package manager. Alternatively you could use an install script from official compiler vendors. Here is an example of how to install the latest stable version of clang as per [the official LLVM install guide](https://apt.llvm.org/). ```bash bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)" ``` If the included test suite is being built and run, a GoogleTest library will be required. Here is an example of installing GoogleTest on a Debian-based Linux environment: ```bash apt install libgtest-dev ``` The precise command and package name will vary depending on the Linux OS you are using. Be sure to consult documentation and the package repository for the system you are using.

For MacOS based systems

Beman libraries require [recent versions of CMake](#build-environment). You can use [`Homebrew`](https://brew.sh/) to install the latest major version of CMake. ```bash brew install cmake ``` A [supported compiler](#supported-platforms) is also available from brew. For example, you can install the latest major release of Clang as: ```bash brew install llvm ```

For Windows

To build Beman libraries, you will need the MSVC compiler. MSVC can be obtained by installing Visual Studio; the free Visual Studio 2022 Community Edition can be downloaded from [Microsoft](https://visualstudio.microsoft.com/vs/community/). After Visual Studio has been installed, you can launch "Developer PowerShell for VS 2022" by typing it into Windows search bar. This shell environment will provide CMake, Ninja, and MSVC, allowing you to build the library and run the tests. Note that you will need to use FetchContent to build GoogleTest. To do so, please see the instructions in the "Build GoogleTest dependency from github.com" dropdown in the [Project specific configure arguments](#project-specific-configure-arguments) section.

Configure and Build the Project Using CMake Presets

This project recommends using CMake Presets to configure, build and test the project. Appropriate presets for major compilers have been included by default. You can use cmake --list-presets to see all available presets.

Here is an example to invoke the gcc-debug preset.

shell cmake --workflow --preset gcc-debug

Generally, there are two kinds of presets, debug and release.

The debug presets are designed to aid development, so it has debugging instrumentation enabled and as many sanitizers turned on as possible.

[!NOTE]

The set of sanitizer supports are different across compilers. You can checkout the exact set of compiler arguments by looking at the toolchain files under the cmake directory.

The release presets are designed for use in production environments, thus they have the highest optimization turned on (e.g. O3).

Configure and Build Manually

While CMake Presets are convenient, you might want to set different configuration or compiler arguments than any provided preset supports.

To configure, build and test the project with extra arguments, you can run this set of commands.

bash cmake -B build -S . -DCMAKE_CXX_STANDARD=20 # Your extra arguments here. cmake --build build ctest --test-dir build

[!IMPORTANT]

Beman projects are passive projects, therefore, you will need to specify the C++ version via CMAKE_CXX_STANDARD when manually configuring the project.

Finding and Fetching GTest from GitHub

If you do not have GoogleTest installed on your development system, you may optionally configure this project to download a known-compatible release of GoogleTest from source and build it as well.

Example commands:

shell cmake -B build -S . \ -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=./infra/cmake/use-fetch-content.cmake \ -DCMAKE_CXX_STANDARD=20 cmake --build build --target all cmake --build build --target test

The precise version of GoogleTest that will be used is maintained in ./lockfile.json.

Project specific configure arguments

When configuring the project manually, you can pass an array of project specific CMake configs to customize your build.

Project specific options are prefixed with BEMAN_CSTRING_VIEW. You can see the list of available options with:

bash cmake -LH | grep "BEMAN_CSTRING_VIEW" -C 2

Details of CMake arguments.

#### `BEMAN_CSTRING_VIEW_BUILD_TESTS` Enable building tests and test infrastructure. Default: ON. Values: { ON, OFF }. You can configure the project to have this option turned off via: ```bash cmake -B build -S . -DCMAKE_CXX_STANDARD=20 -DBEMAN_CSTRING_VIEW_BUILD_TESTS=OFF ``` > [!TIP] > Because this project requires Google Tests as part of its development > dependency, > disable building tests avoids the project from pulling Google Tests from > GitHub. #### `BEMAN_CSTRING_VIEW_BUILD_EXAMPLES` Enable building examples. Default: ON. Values: { ON, OFF }.

Integrate beman.cstring_view into your project

To use beman.cstring_view in your C++ project, include an appropriate beman.cstring_view header from your source code.

```c++

include

```

[!NOTE]

beman.cstring_view headers are to be included with the beman/cstring_view/ directories prefixed. It is not supported to alter include search paths to spell the include target another way. For instance, #include <cstring_view.hpp> is not a supported interface.

How you will link your project against beman.cstring_view will depend on your build system. CMake instructions are provided in following sections.

Linking your project to beman.cstring_view with CMake

For CMake based projects, you will need to use the beman.cstring_view CMake module to define the beman::cstring_view CMake target:

cmake find_package(beman.cstring_view REQUIRED)

You will also need to add beman::cstring_view to the link libraries of any libraries or executables that include beman.cstring_view's header file.

cmake target_link_libraries(yourlib PUBLIC beman::cstring_view)

Produce beman.cstring_view static library locally

You can include cstringview's headers locally by producing a static `libbeman.cstringview.a` library.

bash cmake --workflow --preset gcc-release cmake --install build/gcc-release --prefix /opt/beman.cstring_view

This will generate such directory structure at /opt/beman.cstring_view.

txt /opt/beman.cstring_view ├── include │ └── beman │ └── cstring_view │ └── cstring_view.hpp └── lib └── libbeman.cstring_view.a

Contributing

Please do! You encourage you to checkout our contributor's guide. Issues and pull requests are appreciated.