### Generate Cppreference Documentation Formats

Source: https://github.com/p12tic/cppreference-doc/blob/master/README.md

Commands to transform the raw Cppreference documentation into various local viewing formats. Supported formats include plain HTML, Devhelp, and QT Help. Running `make all` generates all three formats simultaneously, placing results in the 'output/reference' subdirectory or installing them into proper locations.

```Shell
make doc_html
```

```Shell
make doc_devhelp
```

```Shell
make doc_qch
```

```Shell
make all
```

--------------------------------

### std::basic_string Helper Classes and Deduction Guides

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

Details helper classes, specifically `std::hash` specializations for various `std::basic_string` types, and deduction guides introduced in C++17 for simplified template instantiation.

```APIDOC
// Helper classes
hash<std::string> (C++11)
hash<std::wstring> (C++11)
hash<std::u32string> (C++11)
hash<std::u16string> (C++11)
hash<std::pmr::string> (C++20)
hash<std::pmr::wstring> (C++20)
hash<std::pmr::u32string> (C++20)
hash<std::pmr::u16string> (C++20)

// Deduction guides
Deduction guides (C++17)
```

--------------------------------

### std::multiset Deduction Guides (C++17)

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Provides deduction guides for `std::multiset` to simplify template argument deduction when constructing `multiset` objects in C++17 and later.

```APIDOC
Deduction guides (C++17)
```

--------------------------------

### C++ std::basic_string Deduction Guides

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

API documentation for deduction guides available for `std::basic_string` since C++17, simplifying template argument deduction.

```APIDOC
Deduction guides (since C++17)
```

--------------------------------

### C++ Example: Using std::abs with Floating-Point Values

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

This C++ example demonstrates the usage of `std::abs` with various floating-point values, including positive, negative, negative zero, and negative infinity, showcasing its behavior and typical output.

```C++
#include <iostream>
#include <cmath>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

```Output
abs(+3.0) = 3
abs(-3.0) = 3
abs(-0.0) = 0
abs(-Inf) = inf
```

--------------------------------

### C++ String Deduction Guides

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

Documents the deduction guides for `std::basic_string`, which simplify template argument deduction for string types. This feature is available since C++17.

```APIDOC
Concept: Deduction guides for std::basic_string
Description: Provides mechanisms for automatic template argument deduction for `std::basic_string`.
Availability: C++17
Type: concept/feature
```

--------------------------------

### C++ std::abs Example Usage

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_external.html

Demonstrates the usage of `std::abs` with positive, negative, zero, and infinity values, showing how it returns the absolute value for various inputs.

```C++
#include <iostream>
#include <cmath>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### C++ Example: Using std::abs with Floating-Point Values

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_ga.html

Demonstrates the usage of `std::abs` (which is equivalent to `std::fabs` for floating-point types) with positive, negative, zero, and infinite floating-point values, showing the expected output.

```C++
#include <iostream>
#include <cmath>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### C++ Example: Calculate Absolute Value with std::abs

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_ads.html

Demonstrates the usage of `std::abs` to compute the absolute value of positive, negative, zero, and infinite floating-point numbers. It includes necessary headers and prints the results to the console.

```C++
#include <iostream>
#include <cmath>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### C++ std::abs Example Usage

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs.html

Demonstrates the usage of `std::abs` with positive, negative, zero, and infinite floating-point values, printing their absolute values to the console. This example illustrates the function's behavior with special floating-point values.

```cpp
#include <iostream>
#include <cmath>
 
int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### C++ Example Usage of std::abs for Floating-Point Values

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Demonstrates the usage of std::abs (which std::fabs is often an overload for floating-point types) with positive, negative, zero, and infinity floating-point values, printing their absolute values.

```C++
#include <iostream>
#include <cmath>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### C++ Example: Calculating Absolute Value with std::abs

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_seealso.html

This C++ example demonstrates the usage of `std::abs` to calculate the absolute value of positive and negative floating-point numbers. It also illustrates the function's behavior with special IEEE floating-point values such as negative zero (-0.0) and negative infinity (-Inf).

```C++
#include <iostream>
#include <cmath>
 
int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
}
```

--------------------------------

### Configuring Qt Creator for C++ Code Completion Aid

Source: https://github.com/p12tic/cppreference-doc/blob/master/headers/README.md

Steps to integrate the dummy C++ standard library into a Qt Creator project to replace the default C++ library used for code completion. This involves modifying project-specific include paths and configuration files.

```Configuration
1. Add the path to this directory to the $PROJECT.includes file.
2. Define CPPREFERENCE_STDVER and/or CPPREFERENCE_SIMPLIFY_TYPEDEFS to correct values in the $PROJECT.config file.
```

--------------------------------

### Generate Cppreference Release Archives

Source: https://github.com/p12tic/cppreference-doc/blob/master/README.md

Command to package the generated documentation into release archives, which are then uploaded to the official Cppreference archives website.

```Shell
make release
```

--------------------------------

### Acquire Cppreference Documentation Source

Source: https://github.com/p12tic/cppreference-doc/blob/master/README.md

Describes a method for obtaining the raw Cppreference documentation by pulling content directly from the website. This method is generally discouraged due to server load and potential script breakage, with downloading prepared archives being the preferred alternative.

```Shell
make source
```

--------------------------------

### Initialize MediaWiki and Google Analytics

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

This JavaScript snippet initializes MediaWiki loader states and loads various modules, including post-edit actions, user data, page readiness, search suggestions, and specific gadgets like ColiruCompiler and MathJax. It also sets up Google Analytics tracking for the cppreference.com domain, pushing pageview data.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### Initialize MediaWiki and Google Analytics Tracking

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_ads.html

This JavaScript snippet initializes MediaWiki's client-side functionalities, including loading modules for post-edit actions, user data, page readiness, search suggestions, and high-DPI support. It also sets up Google Analytics tracking for page views on cppreference.com.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### MediaWiki Loader and Google Analytics Initialization

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs.html

This JavaScript code initializes MediaWiki's resource loader based on the `window.mw` object's presence and state. It also sets up Google Analytics tracking for the `cppreference.com` domain, pushing pageview data.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### Initialize MediaWiki Loader and Google Analytics

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_ga.html

This JavaScript snippet initializes the MediaWiki loader, sets up user and page states, loads various MediaWiki modules and gadgets, and configures Google Analytics tracking for the cppreference.com website. It ensures proper page functionality and tracks user interactions.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### C++ Preprocessor Macros for Library Configuration

Source: https://github.com/p12tic/cppreference-doc/blob/master/headers/README.md

This section details the preprocessor macros used to configure the dummy C++ standard library's exposed interface. These macros control the C++ standard version and the simplification of integer types and typedefs.

```APIDOC
CPPREFERENCE_STDVER:
  description: Defines the standard version of the interface.
  possible_values: 1998, 2003, 2011, 2014, 2017 (corresponding to C++ standards)

CPPREFERENCE_INT_TYPES_ONLY_IN_STD:
  description: If non-zero, integer types (e.g., std::size_t, std::uint16_t) are defined only in the std namespace.
  possible_values: 0 (default), non-zero

CPPREFERENCE_SIMPLIFY_TYPEDEFS:
  description: If non-zero, exposes simplified typedefs by reducing usage of various traits. Recommended for better resolution in common cases.
  possible_values: 0 (default), non-zero
```

--------------------------------

### Client-Side JavaScript for cppreference.com

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_external.html

This JavaScript block initializes MediaWiki components, sets up Google Analytics tracking for cppreference.com, and loads additional gadgets like ColiruCompiler and MathJax. It determines the Google Analytics host based on the protocol and pushes pageview data.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### std::multiset Member Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Lists the core member functions for `std::multiset`, including constructors for various initialization scenarios, the destructor for resource cleanup, the assignment operator for copying/moving, and a function to retrieve the allocator.

```APIDOC
multiset::multiset
multiset::~multiset
multiset::operator=
multiset::get_allocator
```

--------------------------------

### Google Analytics and MediaWiki Loader Script

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_seealso.html

This JavaScript snippet initializes Google Analytics tracking for cppreference.com and loads various MediaWiki modules and gadgets, including post-edit actions, user information, page readiness, search suggestions, HiDPI support, Coliru Compiler, and MathJax. It ensures proper loading of site functionalities and tracks page views.

```JavaScript
if(window.mw){ mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"}); } if(window.mw){ mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true); } var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-2828341-1']); _gaq.push(['_setDomainName', 'cppreference.com']); _gaq.push(['_trackPageview']);
```

--------------------------------

### C++ Math Functions: Power

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions for power and root calculations, noting their C++ version availability.

```APIDOC
sqrt
cbrt (C++11)
hypot (C++11)
pow
```

--------------------------------

### C++ std::abs and std::fabs Function Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_external.html

Detailed API reference for the `std::abs` and `std::fabs` functions, including their overloads for various numeric types, focusing on floating-point arguments as highlighted in the source.

```APIDOC
std::abs (Absolute Value Function)
  Description: Computes the absolute value of a numeric argument.
  Overloads:
    float abs(float arg);
    double abs(double arg);
    long double abs(long double arg);
    int abs(int arg);
    long abs(long arg);
    long long abs(long long arg);
    std::complex<T> abs(const std::complex<T>& z); (C++11)
  Parameters:
    arg: The numeric value for which to compute the absolute value.
  Return Value:
    The absolute value of 'arg', with the same type as 'arg'.

std::fabs (Floating-Point Absolute Value Function)
  Description: Computes the absolute value of a floating-point argument.
  Overloads:
    float fabs(float arg);
    double fabs(double arg);
    long double fabs(long double arg);
  Parameters:
    arg: The floating-point value for which to compute the absolute value.
  Return Value:
    The absolute value of 'arg', with the same type as 'arg'.
```

--------------------------------

### C++ String Hash Support

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

Documents the `std::hash` class template specializations for various string types, providing hash support. This includes `std::string`, `std::u16string`, `std::u32string`, `std::wstring`, and their `pmr` counterparts. Available since C++11, with `pmr` versions since C++20.

```APIDOC
Class Template Specialization: std::hash<std::string>, std::hash<std::u16string>, std::hash<std::u32string>, std::hash<std::wstring>, std::hash<std::pmr::string>, std::hash<std::pmr::u16string>, std::hash<std::pmr::u32string>, std::hash<std::pmr::wstring>
Description: Provides hash support for strings.
Availability: C++11 (C++20 for pmr versions)
Type: class template specialization
```

--------------------------------

### std::pmr::basic_string Class API Documentation

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

Detailed API specification for the std::pmr::basic_string template class, including its specializations, template parameters, member types, and member functions grouped by functionality.

```APIDOC
Class: std::pmr::basic_string<CharT, Traits, Allocator>
  Specializations:
    std::pmr::string (std::pmr::basic_string<char>)
    std::pmr::wstring (std::pmr::basic_string<wchar_t>) (C++17)
    std::pmr::u16string (std::pmr::basic_string<char16_t>) (C++17)
    std::pmr::u32string (std::pmr::basic_string<char32_t>) (C++17)

  Template Parameters:
    CharT: character type
    Traits: traits class specifying the operations on the character type
    Allocator: Allocator type used to allocate internal storage (concept: Allocator)

  Member Types:
    traits_type: Traits
    value_type: CharT
    allocator_type: Allocator
    size_type: Allocator::size_type (until C++11), std::allocator_traits<Allocator>::size_type (since C++11)
    difference_type: Allocator::difference_type (until C++11), std::allocator_traits<Allocator>::difference_type (since C++11)
    reference: Allocator::reference (until C++11), value_type& (since C++11)
    const_reference: Allocator::const_reference (until C++11), const value_type& (since C++11)
    pointer: Allocator::pointer (until C++11), std::allocator_traits<Allocator>::pointer (since C++11)
    const_pointer: Allocator::const_pointer (until C++11), std::allocator_traits<Allocator>::const_pointer (since C++11)
    iterator: RandomAccessIterator
    const_iterator: Constant RandomAccessIterator
    reverse_iterator: std::reverse_iterator<iterator>
    const_reverse_iterator: std::reverse_iterator<const_iterator>

  Member Functions:
    (constructor): constructs a basic_string (public member function)
    (destructor): destroys the string, deallocating internal storage if used (public member function)
    operator=: assigns values to the string (public member function)
    assign: assign characters to a string (public member function)
    get_allocator: returns the associated allocator (public member function)

    Element Access:
      at: accesses the specified character with bounds checking (public member function)
      operator[]: accesses the specified character (public member function)
      front (C++11): accesses the first character (public member function)
      back (C++11): accesses the last character (public member function)
      data: returns a pointer to the first character of a string (public member function)
      c_str: returns a non-modifiable standard C character array version of the string (public member function)
      operator basic_string_view (C++17): returns a non-modifiable string_view into the entire string (public member function)

    Iterators:
      begin cbegin (C++11): returns an iterator to the beginning (public member function)
      end cend (C++11): returns an iterator to the end (public member function)
      rbegin crbegin (C++11): returns a reverse iterator to the beginning (public member function)
      rend crend (C++11): returns a reverse iterator to the end (public member function)
```

--------------------------------

### C++ std::basic_string Helper Classes (Hash Support)

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

API documentation for `std::hash` class template specializations that provide hashing support for various `std::basic_string` types.

```APIDOC
std::hash<std::string>: hash support for strings (class template specialization) (C++11)
std::hash<std::u16string>: hash support for strings (class template specialization) (C++11)
std::hash<std::u32string>: hash support for strings (class template specialization) (C++11)
std::hash<std::wstring>: hash support for strings (class template specialization) (C++11)
std::hash<std::pmr::string>: hash support for strings (class template specialization) (C++20)
std::hash<std::pmr::u16string>: hash support for strings (class template specialization) (C++20)
std::hash<std::pmr::u32string>: hash support for strings (class template specialization) (C++20)
std::hash<std::pmr::wstring>: hash support for strings (class template specialization) (C++20)
```

--------------------------------

### C++ std::fabs Function API Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_external.html

Detailed API documentation for the `std::fabs` function, including its parameters, return values, and error handling behavior according to IEEE floating-point arithmetic.

```APIDOC
std::fabs (function)
  Description: Computes the absolute value of a floating-point or integral argument.
  Parameters:
    arg: Value of a floating-point or Integral type
  Return value:
    If successful, returns the absolute value of `arg` (`|arg|`).
    The value returned is exact and does not depend on any rounding modes.
  Error handling (IEEE floating-point arithmetic):
    This function is not subject to any of the error conditions specified in math_errhandling.
    If the argument is ±0, +0 is returned.
    If the argument is ±∞, +∞ is returned.
    If the argument is NaN, NaN is returned.
```

--------------------------------

### C++ std::basic_string Input/Output Operations

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

API documentation for functions and operators that facilitate stream input and output with `std::basic_string` objects.

```APIDOC
operator<<, operator>>: performs stream input and output on strings (function template)
getline: read data from an I/O stream into a string (function template)
```

--------------------------------

### std::basic_string Member Functions and Constants Overview

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

A comprehensive list of member functions available for `std::basic_string`, categorized by their primary purpose (modification, search), and associated constants.

```APIDOC
// Modification
basic_string::ends_with (C++20)
basic_string::replace
basic_string::substr
basic_string::copy
basic_string::resize
basic_string::swap

// Search
basic_string::find
basic_string::rfind
basic_string::find_first_of
basic_string::find_first_not_of
basic_string::find_last_of
basic_string::find_last_not_of

// Constants
basic_string::npos
```

--------------------------------

### C++ std::fabs Function API Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_ads.html

Detailed API documentation for the `std::fabs` function, including its parameters, return values, and specific error handling behavior for IEEE floating-point arithmetic.

```APIDOC
Function: std::fabs

Parameters:
  arg:
    Description: Value of a floating-point or Integral type.

Return Value:
  Type: Floating-point
  Description: If successful, returns the absolute value of `arg` (|arg|). The value returned is exact and does not depend on any rounding modes.

Error Handling:
  - This function is not subject to any of the error conditions specified in `math_errhandling`.
  - If the implementation supports IEEE floating-point arithmetic (IEC 60559):
    - If the argument is ±0, +0 is returned.
    - If the argument is ±∞, +∞ is returned.
    - If the argument is NaN, NaN is returned.
```

--------------------------------

### C++ Math Functions: Exponential

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions for exponential and logarithmic calculations, noting their C++ version availability.

```APIDOC
exp
exp2 (C++11)
expm1 (C++11)
log
log10
log1p (C++11)
log2 (C++11)
```

--------------------------------

### C++ std::basic_string Literals

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

API documentation for string literals defined within the `std::literals::string_literals` namespace, enabling convenient creation of `basic_string` from character array literals.

```APIDOC
operator""s: Converts a character array literal to basic_string (function) (C++14)
```

--------------------------------

### C++ Math Functions: Error and Gamma

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions for error and gamma functions, noting their C++ version availability.

```APIDOC
erf (C++11)
erfc (C++11)
lgamma (C++11)
tgamma (C++11)
```

--------------------------------

### std::multiset Observers API

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

API documentation for member functions that return comparison objects used by the `std::multiset`.

```APIDOC
std::multiset::key_comp()
  Description: Returns the function that compares keys.
std::multiset::value_comp()
  Description: Returns the function that compares keys in objects of type value_type.
```

--------------------------------

### C++ Math Functions: Classification and Comparison

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions for classifying and comparing floating-point values, noting their C++ version availability.

```APIDOC
fpclassify (C++11)
isfinite (C++11)
isinf (C++11)
isnan (C++11)
isnormal (C++11)
signbit (C++11)
isgreater (C++11)
isgreaterequal (C++11)
isless (C++11)
islessequal (C++11)
islessgreater (C++11)
isunordered (C++11)
```

--------------------------------

### std::multiset Member Functions Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Documents the public member functions of `std::multiset`, categorized by their purpose (constructors, assignment, allocator access, iterators, and capacity checks). Each entry includes the function name and a brief description of its action.

```APIDOC
(constructor): constructs the multiset
(destructor): destructs the multiset
operator=: assigns values to the container
get_allocator: returns the associated allocator

Iterators:
  begin cbegin: returns an iterator to the beginning
  end cend: returns an iterator to the end
  rbegin crbegin: returns a reverse iterator to the beginning
  rend crend: returns a reverse iterator to the end

Capacity:
  empty: checks whether the container is empty
  size: returns the number of elements
  max_size: returns the maximum possible number of elements
```

--------------------------------

### std::basic_string Class Template API Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

Comprehensive API documentation for the `std::basic_string` class template, detailing its structure, template parameters, member types, and all public member functions for string manipulation, element access, and iterator support.

```APIDOC
std::basic_string<CharT, Traits, Allocator>
  Description: A class template that manages sequences of characters.

  Specializations:
    std::wstring (std::basic_string<wchar_t>)
    std::u16string (C++11) (std::basic_string<char16_t>)
    std::u32string (C++11) (std::basic_string<char32_t>)
    std::pmr::string (C++17) (std::pmr::basic_string<char>)
    std::pmr::wstring (C++17) (std::pmr::basic_string<wchar_t>)
    std::pmr::u16string (C++17) (std::pmr::basic_string<char16_t>)
    std::pmr::u32string (C++17) (std::pmr::basic_string<char32_t>)

  Template Parameters:
    CharT: character type
    Traits: traits class specifying the operations on the character type
    Allocator: Allocator type used to allocate internal storage (concept: Allocator)

  Member Types:
    traits_type: Traits
    value_type: CharT
    allocator_type: Allocator
    size_type: Allocator::size_type (until C++11), std::allocator_traits<Allocator>::size_type (since C++11)
    difference_type: Allocator::difference_type (until C++11), std::allocator_traits<Allocator>::difference_type (since C++11)
    reference: Allocator::reference (until C++11), value_type& (since C++11)
    const_reference: Allocator::const_reference (until C++11), const value_type& (since C++11)
    pointer: Allocator::pointer (until C++11), std::allocator_traits<Allocator>::pointer (since C++11)
    const_pointer: Allocator::const_pointer (until C++11), std::allocator_traits<Allocator>::const_pointer (since C++11)
    iterator: RandomAccessIterator (concept: RandomAccessIterator)
    const_iterator: Constant RandomAccessIterator (concept: RandomAccessIterator)
    reverse_iterator: std::reverse_iterator<iterator>
    const_reverse_iterator: std::reverse_iterator<const_iterator>

  Member Functions:
    (constructor): constructs a basic_string
    (destructor): destroys the string, deallocating internal storage if used
    operator=: assigns values to the string
    assign: assign characters to a string
    get_allocator: returns the associated allocator

    Element Access:
      at: accesses the specified character with bounds checking
      operator[]: accesses the specified character
      front (C++11): accesses the first character
      back (C++11): accesses the last character
      data: returns a pointer to the first character of a string
      c_str: returns a non-modifiable standard C character array version of the string
      operator basic_string_view (C++17): returns a non-modifiable string_view into the entire string

    Iterators:
      begin, cbegin (C++11): returns an iterator to the beginning
      end, cend (C++11): returns an iterator to the end
      rbegin, crbegin (C++11): returns a reverse iterator to the beginning
      rend, crend (C++11): returns a reverse iterator to the end
```

--------------------------------

### C++ Math Functions: Remainder and Absolute Value

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions related to remainder operations and absolute values, noting their C++ version availability.

```APIDOC
fmod
remainder (C++11)
remquo (C++11)
fma (C++11)
fmax (C++11)
fmin (C++11)
fdim (C++11)
nan (C++11)
```

--------------------------------

### C++ Math Macro Constants

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists standard C++ macro constants related to mathematical operations and floating-point categories, noting their C++ version availability.

```APIDOC
HUGE_VALF (C++11)
HUGE_VAL (C++11)
HUGE_VALL (C++11)
INFINITY (C++11)
NAN (C++11)
math_errhandling (C++11)
MATH_ERRNO (C++11)
MATH_ERREXCEPT (C++11)
FP_NORMAL (C++11)
FP_SUBNORMAL (C++11)
FP_ZERO (C++11)
FP_INFINITE (C++11)
FP_NAN (C++11)
```

--------------------------------

### C++ std::basic_string Capacity Methods

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

Methods related to managing the allocated storage and size of a `std::basic_string` object.

```APIDOC
empty()
  Description: checks whether the string is empty
  Type: public member function
```

```APIDOC
size()
length()
  Description: returns the number of characters
  Type: public member function
```

```APIDOC
max_size()
  Description: returns the maximum number of characters
  Type: public member function
```

```APIDOC
reserve()
  Description: reserves storage
  Type: public member function
```

```APIDOC
capacity()
  Description: returns the number of characters that can be held in currently allocated storage
  Type: public member function
```

```APIDOC
shrink_to_fit()
  Description: reduces memory usage by freeing unused memory
  Type: public member function
  Notes: C++11
```

--------------------------------

### C++ Numeric Sign Manipulation Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

API documentation for C++ functions `copysign` and `signbit` which handle the sign of floating-point numbers.

```APIDOC
Name: copysign
Language: C++
Availability: C++11
Description: Copies the sign of a floating point value.
Category: Function
```

```APIDOC
Name: signbit
Language: C++
Availability: C++11
Description: Checks if the given number is negative.
Category: Function
```

--------------------------------

### std::basic_string Class API Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

This section provides a detailed overview of the `std::basic_string` class in C++, listing its various member functions categorized by their functionality, along with their C++ standard version availability.

```APIDOC
Class: std::basic_string

Member functions:
  basic_string::basic_string
  basic_string::operator=
  basic_string::assign
  basic_string::get_allocator

Element access:
  basic_string::at
  basic_string::operator[]
  basic_string::front (C++11)
  basic_string::back (C++11)
  basic_string::data
  basic_string::c_str
  basic_string::operator basic_string_view (C++17)

Iterators:
  basic_string::beginbasic_string::cbegin (C++11)
  basic_string::endbasic_string::cend (C++11)
  basic_string::rbeginbasic_string::crbegin (C++11)
  basic_string::rendbasic_string::crend (C++11)

Capacity:
  basic_string::empty
  basic_string::sizebasic_string::length
  basic_string::max_size
  basic_string::reserve
  basic_string::capacity
  basic_string::shrink_to_fit (C++11)

Operations:
  basic_string::clear
  basic_string::insert
  basic_string::erase
  basic_string::push_back
  basic_string::pop_back (C++11)
  basic_string::append
  basic_string::operator+=
  basic_string::compare
  basic_string::starts_with (C++20)
```

--------------------------------

### C++ Numeric Valarray: abs(std::valarray)

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_external.html

API documentation for the `abs` function template specialized for `std::valarray`, which applies `std::abs` to each element of a valarray.

```APIDOC
abs(std::valarray)
  Description: applies the function std::abs to each element of valarray
  Type: function template
```

--------------------------------

### C++ Algorithm Functions Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

This section lists C++ standard library algorithms related to numerical operations, including transformations and scans. It indicates the C++ standard version where each function was introduced.

```APIDOC
adjacent_difference
```

```APIDOC
partial_sum
```

```APIDOC
reduce (C++17)
```

```APIDOC
transform_reduce (C++17)
```

```APIDOC
inclusive_scan (C++17)
```

```APIDOC
exclusive_scan (C++17)
```

```APIDOC
transform_inclusive_scan (C++17)
```

```APIDOC
transform_exclusive_scan (C++17)
```

--------------------------------

### std::basic_string Non-Member Functions Overview

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

A list of non-member functions that interact with `std::basic_string` objects, covering operators for arithmetic and comparison, I/O streams, and various string-to-numeric conversion utilities.

```APIDOC
operator+
operator==, operator!=, operator<, operator>, operator<=, operator>=
swap(std::basic_string)
operator<<, operator>>
getline
stoi, stol, stoll (C++11)
stoul, stoull (C++11)
stof, stod, stold (C++11)
to_string (C++11)
to_wstring (C++11)
operator""s (C++14)
```

--------------------------------

### C++ Math Functions: Floating Point Manipulation

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_fileinfo.html

Lists C++ standard library functions for manipulating floating-point values, including scaling and decomposition, noting their C++ version availability.

```APIDOC
ldexp
scalbn (C++11)
scalbln (C++11)
ilogb (C++11)
logb (C++11)
frexp
modf
nextafter (C++11)
nexttoward (C++11)
copysign (C++11)
```

--------------------------------

### C++ Bit Operations Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

This section provides a reference for C++ standard library functions designed for bit manipulation, indicating their introduction in C++20.

```APIDOC
bit_cast (C++20)
```

```APIDOC
ispow2 (C++20)
```

```APIDOC
ceil2 (C++20)
```

```APIDOC
floor2 (C++20)
```

```APIDOC
log2p1 (C++20)
```

--------------------------------

### std::multiset Lookup API

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

API documentation for member functions that query elements within a `std::multiset`.

```APIDOC
std::multiset::count()
  Description: Returns the number of elements matching specific key.
std::multiset::find()
  Description: Finds element with specific key.
std::multiset::equal_range()
  Description: Returns range of elements matching a specific key.
std::multiset::lower_bound()
  Description: Returns an iterator to the first element not less than the given key.
std::multiset::upper_bound()
  Description: Returns an iterator to the first element greater than the given key.
```

--------------------------------

### C++ Common Mathematical Functions: Error and Gamma Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

A reference for error and gamma functions available in the C++ standard library, all introduced in C++11.

```APIDOC
erf (C++11)
```

```APIDOC
erfc (C++11)
```

```APIDOC
lgamma (C++11)
```

```APIDOC
tgamma (C++11)
```

--------------------------------

### C++ std::basic_string Numeric Conversion Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string_expected.html

API documentation for functions that convert `std::basic_string` to and from various numeric types (integers, floating-point values).

```APIDOC
stoi, stol, stoll: converts a string to a signed integer (function) (C++11)
stoul, stoull: converts a string to an unsigned integer (function) (C++11)
stof, stod, stold: converts a string to a floating point value (function) (C++11)
to_string: converts an integral or floating point value to string (function) (C++11)
to_wstring: converts an integral or floating point value to wstring (function) (C++11)
```

--------------------------------

### std::multiset Member Types Reference

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Lists the essential member types defined within the `std::multiset` container, providing aliases for key, value, size, difference, comparison functions, allocator, and various iterator and pointer types. Includes C++11 and C++17 updates.

```APIDOC
key_type: Key
value_type: Key
size_type: Unsigned integer type (usually std::size_t)
difference_type: Signed integer type (usually std::ptrdiff_t)
key_compare: Compare
value_compare: Compare
allocator_type: Allocator
reference:
  - Allocator::reference (until C++11)
  - value_type& (since C++11)
const_reference:
  - Allocator::const_reference (until C++11)
  - const value_type& (since C++11)
pointer:
  - Allocator::pointer (until C++11)
  - std::allocator_traits<Allocator>::pointer (since C++11)
const_pointer:
  - Allocator::const_pointer (until C++11)
  - std::allocator_traits<Allocator>::const_pointer (since C++11)
iterator:
  - BidirectionalIterator (until C++11)
  - Constant BidirectionalIterator (since C++11)
const_iterator: Constant BidirectionalIterator
reverse_iterator: std::reverse_iterator<iterator>
const_reverse_iterator: std::reverse_iterator<const_iterator>
node_type (since C++17): a specialization of node handle representing a container node
```

--------------------------------

### std::multiset Observer Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Functions to access the comparison objects used by `std::multiset` for ordering elements (key comparison) and for value comparison.

```APIDOC
multiset::key_comp
multiset::value_comp
```

--------------------------------

### Numeric Absolute Value Functions (C++ and C)

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

API documentation for various `abs` overloads in C++ for integral, complex, and valarray types, and the `fabs` function in C, all computing absolute values or magnitudes.

```APIDOC
Name: abs(int), labs, llabs
Language: C++
Availability: C++11
Description: Computes the absolute value of an integral value (|x|).
Category: Function
```

```APIDOC
Name: abs(std::complex)
Language: C++
Description: Returns the magnitude of a complex number.
Category: Function Template
```

```APIDOC
Name: abs(std::valarray)
Language: C++
Description: Applies the function std::abs to each element of valarray.
Category: Function Template
```

```APIDOC
Name: fabs
Language: C
Description: C documentation for fabs.
```

--------------------------------

### C++ std::abs and std::fabs Function Overloads API

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_data/fabs_noprint.html

Defines the various overloads for `std::abs` and `std::fabs` functions in C++, including their parameters, return types, and specific behaviors for floating-point and integral arguments. It also details error handling and notes on standard revisions.

```APIDOC
Defined in header <cmath>
Defined in header <cstdlib> (since C++17)

float abs( float arg );
double abs( double arg );
long double abs( long double arg );

float fabs( float arg );
double fabs( double arg );
long double fabs( long double arg );
double fabs( Integral arg ); // (since C++11)

Description:
1-6) Computes the absolute value of a floating point value `arg`.
7) A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by (4-6). If any argument has integral type, it is cast to double. If any other argument is long double, then the return type is long double, otherwise it is double.
For integral arguments, the integral overloads of `std::abs` are likely better matches. If `std::abs` is called with an argument of type `X` such that `std::is_unsigned<X>::value` is `true` and `X` cannot be converted to int by integral promotion, the program is ill-formed.

Parameters:
  arg: Value of a floating-point or Integral type

Return value:
  If successful, returns the absolute value of `arg` (`|arg|`). The value returned is exact and does not depend on any rounding modes.

Error handling:
  This function is not subject to any of the error conditions specified in math_errhandling.
  If the implementation supports IEEE floating-point arithmetic (IEC 60559):
  - If the argument is ±0, +0 is returned
  - If the argument is ±∞, +∞ is returned
  - If the argument is NaN, NaN is returned

Notes:
  Between C++11 and C++14, the standard erroneously required `std::abs` to have overloads for integer types returning double. This requirement was removed in C++17 by defect report 2735.
```

--------------------------------

### std::multiset Capacity Management

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/multiset.html

Functions to query the current size and maximum possible size of a `std::multiset`, and to check if the container is empty.

```APIDOC
multiset::empty
multiset::size
multiset::max_size
```

--------------------------------

### C++ std::basic_string Capacity Member Functions

Source: https://github.com/p12tic/cppreference-doc/blob/master/tests/preprocess_cssless_data/basic_string.html

Documents member functions of `std::basic_string` related to managing its allocated storage and character count.

```APIDOC
std::basic_string Capacity Members:
  empty(): checks whether the string is empty (public member function)
  size() / length(): returns the number of characters (public member function)
  max_size(): returns the maximum number of characters (public member function)
  reserve(): reserves storage (public member function)
  capacity(): returns the number of characters that can be held in currently allocated storage (public member function)
  shrink_to_fit() (C++11): reduces memory usage by freeing unused memory (public member function)
```