RcppThread

https://tnagler.github.io/RcppThread/
Admin
RcppThread provides R-friendly threading capabilities in C++ for enhanced parallel processing within...
Tokens:10,042
Snippets:116
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### ThreadPool::getNumThreads

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Gets the current number of active threads in the pool.

```APIDOC
## getNumThreads

### Description
Gets the number of active threads in the pool.

### Signature
`auto getNumThreads() const -> size_t`
```

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

### async

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Launches a function `f` with its arguments `args` asynchronously and returns a future object that will hold the result. Similar to `pushReturn` but may offer different underlying implementation details.

```APIDOC
## async

### Description
Launches a function `f` with its arguments `args` asynchronously and returns a future object that will hold the result. Similar to `pushReturn` but may offer different underlying implementation details.

### Method
`auto`

### Parameters
#### Path Parameters
- **f** (F&&) - Required - The function to execute.
- **args** (Args && ...) - Required - The arguments to pass to the function.
```

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

### pushReturn

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Pushes a function `f` with its arguments `args` to be executed asynchronously and returns a future object that will hold the result.

```APIDOC
## pushReturn

### Description
Pushes a function `f` with its arguments `args` to be executed asynchronously and returns a future object that will hold the result.

### Method
`auto`

### Parameters
#### Path Parameters
- **f** (F&&) - Required - The function to execute.
- **args** (Args && ...) - Required - The arguments to pass to the function.
```

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

### Create a Thread Pool

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Constructs a thread pool with a specified number of worker threads. If nWorkers is 0, all work is done in the main thread.

```C++
ThreadPool pool(2);
```

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

### pushReturn

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Submits a job that returns a value to the global thread pool. It returns an `std::shared_future` which can be used to retrieve the result or rethrow exceptions.

```APIDOC
## pushReturn

### Description
Pushes jobs returning a value to the global thread pool.

### Signature
```cpp
template<class F, class... Args>
auto RcppThread::pushReturn(F&& f, Args && ... args) >
```

### Parameters
- **f** (F&&) - A function taking an arbitrary number of arguments.
- **args** (Args && ...) - A comma-separated list of the other arguments that shall be passed to `f`.

### Returns
An `std::shared_future`, where the user can get the result and rethrow exceptions.
```

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

### push

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Submits a job to the global thread pool. This function returns `void`. For jobs that return a result, use `pushReturn` or `async`.

```APIDOC
## push

### Description
Pushes jobs to the global thread pool.

### Signature
```cpp
template<class F, class... Args>
void RcppThread::push(F&& f, Args && ... args)
```

### Parameters
- **f** (F&&) - A function taking an arbitrary number of arguments.
- **args** (Args && ...) - A comma-separated list of the other arguments that shall be passed to `f`.
```

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

### ThreadPool::globalInstance

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Provides access to the single global instance of the ThreadPool.

```APIDOC
## globalInstance

### Description
Access to the global thread pool instance.

### Signature
`static auto globalInstance() -> ThreadPool&`
```

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

### Asynchronous Job Execution with Return Value

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Similar to pushReturn, this function submits a job to the global thread pool and returns an std::shared_future. Use async() for tasks that produce a result.

```cpp
auto future_result = RcppThread::async(my_async_function, arg1, arg2);
```

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

### ThreadPool Constructor (Default)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Constructs a thread pool with a number of workers equal to the number of available CPU cores.

```APIDOC
## ThreadPool()

### Description
Constructs a thread pool with as many workers as there are cores.

### Signature
`ThreadPool()`
```

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

### ThreadPool::pushReturn

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a function and its arguments to the thread pool and returns a future to the result.

```APIDOC
## pushReturn

### Description
Pushes a function and its arguments to the thread pool and returns a future to the result.

### Signature
`template<class F, class... Args>
auto pushReturn(F&& f, Args && ... args) > -> auto`
```

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

### template<class F, class... Args> auto RcppThread::ThreadPool::pushReturn(F&& f, Args && ... args)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a job (function `f` with arguments `args`) to the thread pool that returns a value. It returns an `std::shared_future` to retrieve the result or rethrow exceptions.

```APIDOC
## template<class F, class... Args> auto RcppThread::ThreadPool::pushReturn(F&& f, Args && ... args)

### Description
Pushes jobs returning a value to the thread pool. Returns an `std::shared_future`, where the user can get the result and rethrow exceptions.

### Parameters
#### Path Parameters
- **f** (F&&) - Required - A function taking an arbitrary number of arguments.
- **args** (Args && ...) - Required - A comma-separated list of the other arguments that shall be passed to `f`.
```

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

### parallelForEach

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Executes a range-based for loop in parallel batches. Similar to `parallelFor`, it uses a global thread pool and can be nested. Manual synchronization is necessary for non-independent iterations.

```APIDOC
## parallelForEach

### Description
Computes a range-based for loop in parallel batches.

### Signature
```cpp
template<class I, class F>
void RcppThread::parallelForEach(I& items, F f, size_t nThreads = std::thread::hardware_concurrency(), size_t nBatches = 0)
```

### Parameters
- **items** (I&) - An object allowing for `items.size()` and whose elements are accessed by the `[]` operator.
- **f** (F) - A function (the 'loop body').
- **nThreads** (size_t) - Limits the number of threads used from the global pool. Defaults to `std::thread::hardware_concurrency()`.
- **nBatches** (size_t) - The number of batches to create; the default (0) uses work stealing to distribute tasks.
```

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

### template<class F, class I> void RcppThread::ThreadPool::parallelForEach(I& items, F f, size_t nBatches = 0)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Computes a for-each loop in parallel batches. Tasks are distributed using work stealing by default.

```APIDOC
## template<class F, class I> void RcppThread::ThreadPool::parallelForEach(I& items, F f, size_t nBatches = 0)

### Description
Computes a for-each loop in parallel batches. Consider the following code:
```
std::vector<double> x(10, 1.0);
for (auto& xx : x) {
    xx *= 2;
}
```
The parallel `ThreadPool` equivalent is
```
ThreadPool pool(2);
pool.parallelForEach(x, [&] (double& xx) {
    xx *= 2;
});
```
**Caution**: if the iterations are not independent from another, the tasks need to be synchronized manually (e.g., using mutexes).

### Parameters
#### Path Parameters
- **items** (I&) - Required - An object allowing for `std::begin()`/`std::end()` and whose elements can be accessed by the `[]` operator.
- **f** (F) - Required - A function (the 'loop body').
- **nBatches** (size_t) - Optional - The number of batches to create; the default (0) uses work stealing to distribute tasks.
```

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

### RMonitor::instance

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Provides access to the singleton RMonitor instance. It constructs the instance upon its first call and returns a reference to it.

```APIDOC
## RMonitor::instance

### Description
Returns a reference to the singleton RMonitor instance. The instance is constructed on the first call to this method.

### Signature
`static auto instance() -> RMonitor&`
```

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

### Parallel ForEach Loop with RcppThread

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Provides a parallel alternative to C++ range-based for loops using RcppThread's parallelForEach. Use when iterating over containers where elements can be accessed by index.

```cpp
std::vector<double> x(10, 1.0);
for (auto& xx : x) {
    xx *= 2;
}
```

```cpp
parallelFor(x, [&] (double& xx) {
    xx *= 2;
});
```

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

### push

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Pushes a function `f` with its arguments `args` to be executed asynchronously in a separate thread.

```APIDOC
## push

### Description
Pushes a function `f` with its arguments `args` to be executed asynchronously in a separate thread.

### Method
`void`

### Parameters
#### Path Parameters
- **f** (F&&) - Required - The function to execute.
- **args** (Args && ...) - Required - The arguments to pass to the function.
```

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

### parallelFor

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Executes a function `f` over a range of integers from `begin` to `end` in parallel. It allows specifying the number of threads and batches for execution.

```APIDOC
## parallelFor

### Description
Executes a function `f` over a range of integers from `begin` to `end` in parallel. It allows specifying the number of threads and batches for execution.

### Method
`void`

### Parameters
#### Path Parameters
- **begin** (int) - Required - The starting integer of the range.
- **end** (int) - Required - The ending integer of the range.
- **f** (F) - Required - The function to be executed in parallel.
- **nThreads** (size_t) - Optional - The number of threads to use. Defaults to `std::thread::hardware_concurrency()`.
- **nBatches** (size_t) - Optional - The number of batches to divide the work into. Defaults to 0.
```

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

### parallelFor

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Executes an index-based for loop in parallel batches. It dispatches tasks to a global thread pool and can be safely nested or called multiple times with minimal overhead. Caution: manual synchronization is required if iterations are not independent.

```APIDOC
## parallelFor

### Description
Computes an index-based for loop in parallel batches.

### Signature
```cpp
template<class F>
void RcppThread::parallelFor(int begin, int end, F f, size_t nThreads = std::thread::hardware_concurrency(), size_t nBatches = 0)
```

### Parameters
- **begin** (int) - First index of the loop.
- **end** (int) - The loop runs in the range `[begin, end)`.
- **f** (F) - A function (the 'loop body').
- **nThreads** (size_t) - Limits the number of threads used from the global pool. Defaults to `std::thread::hardware_concurrency()`.
- **nBatches** (size_t) - The number of batches to create; the default (0) uses work stealing to distribute tasks.
```

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

### Map a Function Over Items

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Applies a function to each item in a collection, potentially in parallel. The collection must support std::begin and std::end.

```C++
pool.map(my_function, my_items);
```

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

### parallelForEach

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Executes a function `f` over a collection of items in parallel. It allows specifying the number of threads and batches for execution.

```APIDOC
## parallelForEach

### Description
Executes a function `f` over a collection of items in parallel. It allows specifying the number of threads and batches for execution.

### Method
`void`

### Parameters
#### Path Parameters
- **items** (I&) - Required - A reference to the collection of items to iterate over.
- **f** (F) - Required - The function to be executed in parallel for each item.
- **nThreads** (size_t) - Optional - The number of threads to use. Defaults to `std::thread::hardware_concurrency()`.
- **nBatches** (size_t) - Optional - The number of batches to divide the work into. Defaults to 0.
```

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

### async

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Submits a job that returns a value to the global thread pool. It returns an `std::shared_future` for retrieving results or rethrowing exceptions.

```APIDOC
## async

### Description
Pushes jobs returning a value to the global thread pool.

### Signature
```cpp
template<class F, class... Args>
auto RcppThread::async(F&& f, Args && ... args) >
```

### Parameters
- **f** (F&&) - A function taking an arbitrary number of arguments.
- **args** (Args && ...) - A comma-separated list of the other arguments that shall be passed to `f`.

### Returns
An `std::shared_future`, where the user can get the result and rethrow exceptions.
```

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

### wait

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Waits for all currently running asynchronous tasks to complete.

```APIDOC
## wait

### Description
Waits for all currently running asynchronous tasks to complete.

### Method
`void`
```

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

### RcppThread::ProgressBar::printProgress

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ProgressBar.html

Prints the current progress to the R console, including an estimate of the remaining time.

```APIDOC
## void RcppThread::ProgressBar::printProgress() virtual private

### Description
Prints a progress bar to the R console (+ an estimate of remaining time).
```

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

### template<class F, class... Args> void RcppThread::ThreadPool::push(F&& f, Args && ... args)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a job (function `f` with arguments `args`) to the thread pool for asynchronous execution. This method returns void.

```APIDOC
## template<class F, class... Args> void RcppThread::ThreadPool::push(F&& f, Args && ... args)

### Description
Pushes jobs to the thread pool. The function returns void; if a job returns a result, use `pushReturn()`.

### Parameters
#### Path Parameters
- **f** (F&&) - Required - A function taking an arbitrary number of arguments.
- **args** (Args && ...) - Required - A comma-separated list of the other arguments that shall be passed to `f`.
```

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

### ThreadPool Constructor (Custom)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Constructs a thread pool with a specified number of worker threads.

```APIDOC
## ThreadPool(size_t nWorkers)

### Description
Constructs a thread pool with a specified number of worker threads.

### Signature
`ThreadPool(size_t nWorkers) explicit`
```

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

### RcppThread::Thread::join

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1Thread.html

Joins the thread, synchronizing with R and checking for user interruptions periodically. This method ensures that the main R thread is responsive while background threads are executing.

```APIDOC
## void RcppThread::Thread::join()

### Description
Joins the thread, synchronizing with R and checking for user interruptions periodically. This method ensures that the main R thread is responsive while background threads are executing.

### Method
void

### Endpoint
N/A (C++ method)

### Parameters
None

### Response
None (modifies thread state)

### Example
```cpp
RcppThread::Thread my_thread(my_function);
// ... do some work ...
my_thread.join(); // Wait for the thread to finish and synchronize with R
```
```

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

### ThreadPool::parallelForEach

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Executes a function for each item in a collection in parallel.

```APIDOC
## parallelForEach

### Description
Executes a function for each item in a collection in parallel.

### Signature
`template<class F, class I>
void parallelForEach(I& items, F f, size_t nBatches = 0)`
```

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

### template<class F> void RcppThread::ThreadPool::parallelFor(int begin, int end, F f, size_t nBatches = 0)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Computes an index-based for loop in parallel batches. Tasks are distributed using work stealing by default.

```APIDOC
## template<class F> void RcppThread::ThreadPool::parallelFor(int begin, int end, F f, size_t nBatches = 0)

### Description
Computes an index-based for loop in parallel batches. Consider the following code:
```
std::vector<double> x(10);
for (size_t i = 0; i < x.size(); i++) {
    x[i] = i;
}
```
The parallel equivalent is given by:
```
ThreadPool pool(2);
pool.forIndex(0, 10, [&] (size_t i) {
    x[i] = i;
});
```
**Caution**: if the iterations are not independent from another, the tasks need to be synchronized manually (e.g., using mutexes).

### Parameters
#### Path Parameters
- **begin** (int) - Required - First index of the loop.
- **end** (int) - Required - The loop runs in the range `[begin, end)`.
- **f** (F) - Required - An object callable as a function (the 'loop body'); typically a lambda.
- **nBatches** (size_t) - Optional - The number of batches to create; the default (0) uses work stealing to distribute tasks.
```

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

### RcppThread::ProgressBar::ProgressBar Constructor

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ProgressBar.html

Constructs a ProgressBar object to display progress. It takes the total number of iterations and the interval (in seconds) at which to print updates.

```APIDOC
## RcppThread::ProgressBar::ProgressBar(size_t numIt, size_t printEvery)

### Description
Constructs a progress bar object.

### Parameters
#### Path Parameters
- **numIt** (size_t) - Required - Total number of iterations.
- **printEvery** (size_t) - Required - How regularly to print updates (in seconds).
```

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

### Pushing Jobs to Global Thread Pool

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Submits a function and its arguments to the global RcppThread pool for asynchronous execution. Use push() for tasks that do not return a value.

```cpp
RcppThread::push(my_function, arg1, arg2);
```

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

### Push a Job to the Thread Pool

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a job (function and its arguments) to the thread pool for asynchronous execution. This method is for functions that do not return a value.

```C++
pool.push(my_function, arg1, arg2);
```

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

### ThreadPool::push

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a function and its arguments to the thread pool for asynchronous execution.

```APIDOC
## push

### Description
Pushes a function and its arguments to the thread pool for execution.

### Signature
`template<class F, class... Args>
void push(F&& f, Args && ... args)`
```

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

### Parallel For Loop

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Executes a for loop in parallel. The loop runs over the range [begin, end). Caution: ensure iterations are independent or use manual synchronization.

```C++
std::vector<double> x(10);
for (size_t i = 0; i < x.size(); i++) {
    x[i] = i;
}

ThreadPool pool(2);
pool.forIndex(0, 10, [&] (size_t i) {
    x[i] = i;
});
```

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

### ThreadPool::parallelFor

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Executes a loop in parallel over a given range.

```APIDOC
## parallelFor

### Description
Executes a loop in parallel over a given range.

### Signature
`template<class F>
void parallelFor(int begin, int end, F f, size_t nBatches = 0)`
```

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

### ThreadPool::join

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Waits for all jobs to finish and joins all worker threads.

```APIDOC
## join

### Description
Waits for all jobs to finish.

### Signature
`void join()`
```

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

### Parallel For Each Loop

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Executes a for-each loop in parallel. The items collection must support std::begin, std::end, and operator[]. Caution: ensure iterations are independent or use manual synchronization.

```C++
std::vector<double> x(10, 1.0);
for (auto& xx : x) {
    xx *= 2;
}

ThreadPool pool(2);
pool.parallelForEach(x, [&] (double& xx) {
    xx *= 2;
});
```

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

### Enable Automatic Overrides for C++ Streams and Threads

Source: https://tnagler.github.io/RcppThread/overrides.html

Use these preprocessor directives before including RcppThread headers to automatically replace std::cout, std::cerr, and std::thread with their RcppThread counterparts.

```cpp
#define RCPPTHREAD_OVERRIDE_COUT 1    // std::cout override
#define RCPPTHREAD_OVERRIDE_CERR 1    // std::cerr override
#define RCPPTHREAD_OVERRIDE_THREAD 1  // std::thread override
```

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

### template<class F, class I> void RcppThread::ThreadPool::map(F&& f, I&& items)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Maps a function `f` over a collection of `items`, potentially executing tasks in parallel across the thread pool.

```APIDOC
## template<class F, class I> void RcppThread::ThreadPool::map(F&& f, I&& items)

### Description
Maps a function on a list of items, possibly running tasks in parallel.

### Parameters
#### Path Parameters
- **f** (F&&) - Required - Function to be mapped.
- **items** (I&&) - Required - An object containing the items on which `f` shall be mapped; must allow for `auto` loops (i.e., `std::begin(I)`/ `std::end(I)` must be defined).
```

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

### Parallel For Loop with RcppThread

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Replaces a standard C++ for loop with a parallel equivalent using RcppThread's parallelFor. Suitable for index-based loops where iterations are independent.

```cpp
std::vector<double> x(10);
for (size_t i = 0; i < x.size(); i++) {
    x[i] = i;
}
```

```cpp
parallelFor(0, 10, [&] (size_t i) {
    x[i] = i;
});
```

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

### Pushing Jobs with Return Value

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Submits a function that returns a value to the global RcppThread pool. Returns an std::shared_future to retrieve the result or rethrow exceptions.

```cpp
auto future_result = RcppThread::pushReturn(my_function_returning_value, arg1);
```

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

### ThreadPool::map

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Applies a function to each item in a range and collects the results.

```APIDOC
## map

### Description
Applies a function to each item in a range, processing them in parallel.

### Signature
`template<class F, class I>
void map(F&& f, I&& items)`
```

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

### Push a Job with a Return Value

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Pushes a job to the thread pool that returns a value. It returns an std::shared_future to retrieve the result or rethrow exceptions.

```C++
auto future_result = pool.pushReturn(my_function_returning_value, arg1, arg2);
```

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

### ThreadPool::resize

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Resizes the thread pool to a specified number of threads.

```APIDOC
## resize

### Description
Resizes the thread pool to the specified number of threads.

### Signature
`void resize(size_t threads)`
```

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

### RMonitor::safelyPrint

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Safely prints an object to the R console. If called from the main thread, the object is printed immediately. Otherwise, it's added to a buffer for deferred printing.

```APIDOC
## RMonitor::safelyPrint

### Description
Prints a given object to the R console in a thread-safe manner. If the method is called from the main thread, the object is printed directly. If called from a different thread, the object is added to a buffer and printed later.

### Signature
`template<class T> void safelyPrint(const T& object)` (protected)

### Parameters
* **object** (T) - Required - A string or an object coercible to a string that needs to be printed.
```

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

### wait

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Waits for all submitted jobs to complete. This function also checks for interruptions, but only when called from the main thread. It has no effect when called from other threads.

```APIDOC
## wait

### Description
Waits for all jobs to finish and checks for interruptions.

### Signature
```cpp
void RcppThread::wait()
```

### Notes
- Only checks for interruptions when called from the main thread.
- Does nothing when called from other threads.
```

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

### checkUserInterrupt

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Checks for user interruption. If `condition` is true, it throws a `UserInterruptException` if an interruption is detected.

```APIDOC
## checkUserInterrupt

### Description
Checks for user interruption. If `condition` is true, it throws a `UserInterruptException` if an interruption is detected.

### Method
`void`

### Parameters
#### Path Parameters
- **condition** (bool) - Optional - If true, checks for user interrupt. Defaults to true.
```

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

### RPrinter::operator<< (ostream manipulator)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Handles stream manipulators (like std::endl) for printing to the R console. It prints the manipulator's effect to the R console if called from the main thread, otherwise it buffers the effect for deferred printing.

```APIDOC
## RPrinter& RcppThread::RPrinter::operator<<(std::ostream&(*)(std::ostream&) object)

### Description
Prints `object` to the R console if called from the main thread; otherwise, adds a printable version of `object` to a buffer for deferred printing. Declared as a friend in `RMonitor`.

### Parameters
#### Path Parameters
- **object** (std::ostream&(*)(std::ostream&)) - Required - A stream manipulator function.
```

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

### ThreadPool::wait

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Waits for all currently submitted jobs in the thread pool to complete.

```APIDOC
## wait

### Description
Waits for all jobs to finish.

### Signature
`void wait()`
```

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

### RPrinter Output Operator (Stream Manipulator)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Overload for the output stream operator that accepts a stream manipulator function. It applies the manipulator to the R console output if called from the main thread, or buffers it for later printing if called from a different thread.

```cpp
auto operator<<(std::ostream&(*)(std::ostream&) object) -> RPrinter&
    
```

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

### Wait for Jobs to Finish

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Waits for all submitted jobs in the thread pool to complete. This method only has an effect when called from the thread that created the pool.

```C++
pool.wait();
```

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

### Waiting for All Jobs to Finish

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Blocks the main thread until all submitted jobs in the RcppThread pool have completed. Primarily used for synchronization and checking for interruptions.

```cpp
RcppThread::wait();
```

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

### RMonitor::safelyPrintErr

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Safely prints an object to the R error stream. If called from the main thread, the object is printed immediately. Otherwise, it's added to a buffer for deferred printing.

```APIDOC
## RMonitor::safelyPrintErr

### Description
Prints a given object to the R error stream in a thread-safe manner. If the method is called from the main thread, the object is printed directly to stderr. If called from a different thread, the object is added to a buffer and printed later.

### Signature
`template<class T> void safelyPrintErr(const T& object)` (protected)

### Parameters
* **object** (T) - Required - A string or an object coercible to a string that needs to be printed to the error stream.
```

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

### RPrinter::operator<< (const T)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Prints an object to the R console if called from the main thread. Otherwise, it buffers a printable version of the object for deferred printing. This overload accepts a const reference to the object.

```APIDOC
## RPrinter& RcppThread::RPrinter::operator<<(const T& object)

### Description
Prints `object` to the R console if called from the main thread; otherwise, adds a printable version of `object` to a buffer for deferred printing. Declared as a friend in `RMonitor`.

### Parameters
#### Path Parameters
- **object** (const T&) - Required - A string or coercible object to print.
```

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

### RErrPrinter::operator<< (std::ostream&(*)(std::ostream&) object)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RErrPrinter.html

Handles stream manipulators (like std::endl) for the R error stream. If called from the main thread, it applies the manipulator immediately. Otherwise, it buffers the operation for deferred execution.

```APIDOC
## RErrPrinter::operator<< (std::ostream&(*)(std::ostream&) object)

### Description
Handles stream manipulators (like std::endl) for the R error stream. If called from the main thread, it applies the manipulator immediately. Otherwise, it buffers the operation for deferred execution.

### Method
operator<<

### Parameters
#### Path Parameters
- **object** (std::ostream&(*)(std::ostream&)) - Required - A stream manipulator function.

### Functionality
This operator is declared as a friend in `RMonitor` and is designed for safe console output from threaded R code.
```

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

### ThreadPool Destructor

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Destructor that joins all threads if possible, ensuring they complete their tasks.

```APIDOC
## ~ThreadPool()

### Description
Destructor joins all threads if possible.

### Signature
`~ThreadPool() noexcept`
```

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

### RPrinter Output Operator (Const)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Overload for the output stream operator that accepts a constant object. It prints the object to the R console if called from the main thread, or buffers it for later printing if called from a different thread.

```cpp
template<class T>
auto operator<<(const T& object) -> RPrinter&
     
```

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

### RPrinter::operator<< (non-const T)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Prints an object to the R console if called from the main thread. Otherwise, it buffers a printable version of the object for deferred printing. This overload accepts a non-const reference to the object.

```APIDOC
## RPrinter& RcppThread::RPrinter::operator<<(T& object)

### Description
Prints `object` to the R console if called from the main thread; otherwise, adds a printable version of `object` to a buffer for deferred printing. Declared as a friend in `RMonitor`.

### Parameters
#### Path Parameters
- **object** (T&) - Required - A string or coercible object to print.
```

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

### RPrinter Output Operator (Mutable)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RPrinter.html

Overload for the output stream operator that accepts a mutable object. It prints the object to the R console if called from the main thread, or buffers it for later printing if called from a different thread.

```cpp
template<class T>
auto operator<<(T& object) -> RPrinter&
     
```

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

### RMonitor::safelyIsInterrupted

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Checks for user interruptions in a thread-safe manner. If called from the main thread, it returns the actual interruption status; otherwise, it returns the last known state.

```APIDOC
## RMonitor::safelyIsInterrupted

### Description
Checks for user interruptions. This method is thread-safe, returning `true` only when called from the main thread and an interruption has been detected. Otherwise, it returns the last known interruption state.

### Signature
`auto safelyIsInterrupted() -> bool` (protected)
```

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

### RErrPrinter::operator<< (T& object)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RErrPrinter.html

Prints a string or coercible object to the R error stream. If called from the main thread, it prints immediately. Otherwise, it buffers the printable version of the object for deferred printing.

```APIDOC
## RErrPrinter::operator<< (T& object)

### Description
Prints a string or coercible object to the R error stream. If called from the main thread, it prints immediately. Otherwise, it buffers the printable version of the object for deferred printing.

### Method
operator<<

### Parameters
#### Path Parameters
- **object** (T&) - Required - A string or coercible object to print.

### Functionality
This operator is declared as a friend in `RMonitor` and is designed for safe console output from threaded R code.
```

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

### RcppThread::ThreadPool::ThreadPool(size_t nWorkers)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Constructs a thread pool with a specified number of worker threads. If nWorkers is 0, all tasks are executed in the main thread.

```APIDOC
## RcppThread::ThreadPool::ThreadPool(size_t nWorkers)

### Description
Constructs a thread pool with `nWorkers` threads. If `nWorkers` is 0, all work pushed to the pool will be done in the main thread.

### Parameters
#### Path Parameters
- **nWorkers** (size_t) - Required - The number of worker threads to create.
```

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

### Checking if an Interrupt is Active

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Returns a boolean indicating whether a user interrupt is active. This check is only performed on the main thread; otherwise, it returns false.

```cpp
bool interrupted = RcppThread::isInterrupted(true);
```

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

### Resize Thread Pool

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Changes the number of active worker threads in the pool. This can be used to dynamically adjust concurrency.

```C++
pool.resize(4);
```

```C++
pool.setNumThreads(4);
```

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

### void RcppThread::ThreadPool::wait()

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Waits for all submitted jobs to finish. This method is intended to be called from the thread that created the pool; it does nothing when called from other threads.

```APIDOC
## void RcppThread::ThreadPool::wait()

### Description
Waits for all jobs to finish and checks for interruptions, but only from the thread that created the pool. Does nothing when called from other threads.
```

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

### RErrPrinter::operator<< (const T& object)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RErrPrinter.html

Prints a string or coercible object to the R error stream. If called from the main thread, it prints immediately. Otherwise, it buffers the printable version of the object for deferred printing.

```APIDOC
## RErrPrinter::operator<< (const T& object)

### Description
Prints a string or coercible object to the R error stream. If called from the main thread, it prints immediately. Otherwise, it buffers the printable version of the object for deferred printing.

### Method
operator<<

### Parameters
#### Path Parameters
- **object** (const T&) - Required - A string or coercible object to print.

### Functionality
This operator is declared as a friend in `RMonitor` and is designed for safe console output from threaded R code.
```

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

### isInterrupted

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Returns a boolean indicating whether a user interruption has occurred. If `condition` is true, it returns the interruption status; otherwise, it might reset or have no effect depending on implementation.

```APIDOC
## isInterrupted

### Description
Returns a boolean indicating whether a user interruption has occurred. If `condition` is true, it returns the interruption status; otherwise, it might reset or have no effect depending on implementation.

### Method
`bool`

### Parameters
#### Path Parameters
- **condition** (bool) - Optional - If true, returns the interruption status. Defaults to true.
```

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

### checkUserInterrupt

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Checks for user interruptions, conditionally. This function is declared as a friend of RMonitor and operates only when called from the main thread.

```APIDOC
## checkUserInterrupt

### Description
Checks for user interruptions. This function is a friend of the `RMonitor` class and performs the check only if called from the main thread. An optional condition can be provided to gate the execution of the check.

### Signature
`void checkUserInterrupt(bool condition)`

### Parameters
* **condition** (bool) - Optional - A condition that must be true for the interruption check to be performed.
```

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

### Checking for User Interrupts

Source: https://tnagler.github.io/RcppThread/namespaceRcppThread.html

Conditionally checks if a user interrupt has occurred. This function is intended for use in the main thread and is declared as a friend in RMonitor.

```cpp
RcppThread::checkUserInterrupt(true);
```

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

### ThreadPool::setNumThreads

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Sets the number of active threads in the pool.

```APIDOC
## setNumThreads

### Description
Sets the number of active threads in the pool.

### Signature
`void setNumThreads(size_t threads)`
```

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

### void RcppThread::ThreadPool::resize(size_t threads)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Changes the number of active worker threads in the pool.

```APIDOC
## void RcppThread::ThreadPool::resize(size_t threads)

### Description
Changes the number of threads in the pool.

### Parameters
#### Path Parameters
- **threads** (size_t) - Required - The desired number of threads.
```

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

### isInterrupted

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1RMonitor.html

Determines if an interruption has occurred, with thread-safety considerations. Returns false if not called from the main thread.

```APIDOC
## isInterrupted

### Description
Checks if an interruption has occurred. This function, declared as a friend of `RMonitor`, returns `true` if an interruption is detected and the call originates from the main thread. Otherwise, it returns `false`.

### Signature
`auto isInterrupted(bool condition) -> bool`

### Parameters
* **condition** (bool) - Optional - A condition that must be true for the interruption check to be performed.
```

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

### void RcppThread::ThreadPool::setNumThreads(size_t threads)

Source: https://tnagler.github.io/RcppThread/classRcppThread_1_1ThreadPool.html

Sets the number of active threads in the pool to the specified value.

```APIDOC
## void RcppThread::ThreadPool::setNumThreads(size_t threads)

### Description
Sets the number of active threads in the pool.

### Parameters
#### Path Parameters
- **threads** (size_t) - Required - The desired number of threads.
```
Tokens:
Raw