Skip to content

TsukiNi22/ai-utils / skills/libutils/libutils

libutils

Verified

Reference of Tsukini's C++20 library libutils (namespace utils::, github TsukiNi22/libutils) - every section, header, class and public method with the version and commit hash it was generated from, how to link/include it, exceptions/error codes, verbose, and how to find what changed since. Use whenever code uses or could use libutils (utils::..., include "utils/...", find_package(utils)), when the user asks which libutils class/function does something, how to use one, or what is new in libutils, instead of searching the library sources.

FileKindSize
SKILL.mdskill md14.6 KB
reference/VERSION.mdmarkdown612 B
reference/api/algorithms.mdmarkdown10.0 KB
reference/api/arguments.mdmarkdown8.4 KB
reference/api/attribute.mdmarkdown9.0 KB
reference/api/cli.mdmarkdown5.0 KB
reference/api/concepts.mdmarkdown3.0 KB
reference/api/encapsulation.mdmarkdown9.8 KB
reference/api/exception.mdmarkdown6.7 KB
reference/api/manip.mdmarkdown10.9 KB
reference/api/math.mdmarkdown2.3 KB
reference/api/network.mdmarkdown8.4 KB
reference/api/platform.mdmarkdown6.0 KB
reference/api/pool.mdmarkdown5.1 KB
reference/api/root.mdmarkdown2.2 KB
reference/api/security.mdmarkdown8.8 KB
reference/api/system.mdmarkdown10.7 KB
reference/api/type.mdmarkdown38.5 KB
reference/api/verbose.mdmarkdown3.6 KB
reference/exception-codes.mdmarkdown7.6 KB
reference/index.mdmarkdown20.0 KB
scripts/check.shexecutablescript2.7 KB
scripts/gen_api.pyexecutablescript20.8 KB
scripts/update.shexecutablescript2.3 KB

reference/api/pool.md

View on GitHub
# libutils `pool`

Generated from libutils `v4.3.1` (commit `7913070`, 2026-10-22) by `scripts/gen_api.py`, do not edit by hand.

## `utils/pool/Cluster.hpp`

Cluster class definition

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<typename T> class Cluster: private utils::security::observer::Observer<"Cluster"> {
    std::size_t size(void) const;
    void apply(std::function<void(T&)> fn);
    template<typename... Args> requires std::constructible_from<T, Args&&...> void spawn(Args&&... args);
    template<typename... Args> void spawn(std::size_t n, Args&&... args); // spawn n
    void kill(void); // kill all
    void kill(std::size_t n); // kill n last
    Cluster& operator=(Cluster&& other) = default;
    Cluster() = default;
    Cluster(Cluster&& other) = default;
    ~Cluster() = default;
};
```

## `utils/pool/middleware/Middlewares.hpp`

Global middlewares include

## `utils/pool/middleware/MiddlewaresType.hpp`

Declaration of the Middleware type for void & non void function

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<typename T> struct MiddlewareType {
    using type = std::function<void(T)>;
};
template<> struct MiddlewareType<void> {
    using type = std::function<void(void)>;
};
```

## `utils/pool/middleware/Middlewares_t-t.hpp`

Declaration of the Middlewares<T, U>

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<typename T, typename U> class Middlewares: private utils::security::observer::Observer<"Middlewares"> {
    std::vector<utils::pool::Middleware<T>> before;
    std::vector<utils::pool::Middleware<U>> after;
    void clear(void);
    void addBefore(const utils::pool::Middleware<T>& toAdd);
    void addBefore(const std::vector<utils::pool::Middleware<T>>& toAdds);
    void addAfter(const utils::pool::Middleware<U>& toAdd);
    void addAfter(const std::vector<utils::pool::Middleware<U>>& toAdds);
    void callBefore(T arg) const;
    void callAfter(U arg) const;
    Middlewares& operator=(const Middlewares& other);
    Middlewares& operator=(Middlewares&& other);
    Middlewares() = default;
    Middlewares(const Middlewares& other);
    Middlewares(Middlewares&& other);
    ~Middlewares() = default;
};
```

## `utils/pool/middleware/Middlewares_t-void.hpp`

Declaration of the Middlewares<T, void>

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<typename T> class Middlewares<T, void>: private utils::security::observer::Observer<"Middlewares"> {
    std::vector<utils::pool::Middleware<T>> before;
    std::vector<utils::pool::Middleware<void>> after;
    void clear(void);
    void addBefore(const utils::pool::Middleware<T>& toAdd);
    void addBefore(const std::vector<utils::pool::Middleware<T>>& toAdds);
    void addAfter(const utils::pool::Middleware<void>& toAdd);
    void addAfter(const std::vector<utils::pool::Middleware<void>>& toAdds);
    void callBefore(T arg) const;
    void callAfter(void) const;
    Middlewares& operator=(const Middlewares& other);
    Middlewares& operator=(Middlewares&& other);
    Middlewares() = default;
    Middlewares(const Middlewares& other);
    Middlewares(Middlewares&& other);
    ~Middlewares() = default;
};
```

## `utils/pool/middleware/Middlewares_void-t.hpp`

Declaration of the Middlewares<void, T>

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<typename U> class Middlewares<void, U>: private utils::security::observer::Observer<"Middlewares"> {
    std::vector<utils::pool::Middleware<void>> before;
    std::vector<utils::pool::Middleware<U>> after;
    void clear(void);
    void addBefore(const utils::pool::Middleware<void>& toAdd);
    void addBefore(const std::vector<utils::pool::Middleware<void>>& toAdds);
    void addAfter(const utils::pool::Middleware<U>& toAdd);
    void addAfter(const std::vector<utils::pool::Middleware<U>>& toAdds);
    void callBefore(void) const;
    void callAfter(U arg) const;
    Middlewares& operator=(const Middlewares& other);
    Middlewares& operator=(Middlewares&& other);
    Middlewares() = default;
    Middlewares(const Middlewares& other);
    Middlewares(Middlewares&& other);
    ~Middlewares() = default;
};
```

## `utils/pool/middleware/Middlewares_void-void.hpp`

Declaration of the Middlewares<void, void>

Namespace: `utils::pool`

```cpp
// namespace utils::pool
template<> class Middlewares<void, void>: private utils::security::observer::Observer<"Middlewares"> {
    std::vector<utils::pool::Middleware<void>> before;
    std::vector<utils::pool::Middleware<void>> after;
    void clear(void);
    void addBefore(const utils::pool::Middleware<void>& toAdd);
    void addBefore(const std::vector<utils::pool::Middleware<void>>& toAdds);
    void addAfter(const utils::pool::Middleware<void>& toAdd);
    void addAfter(const std::vector<utils::pool::Middleware<void>>& toAdds);
    void callBefore(void) const;
    void callAfter(void) const;
    Middlewares& operator=(const Middlewares& other);
    Middlewares& operator=(Middlewares&& other);
    Middlewares() = default;
    Middlewares(const Middlewares& other);
    Middlewares(Middlewares&& other);
    ~Middlewares() = default;
};
```
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 319kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 319kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 319kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 319kUpdated Claude CodeCodexVerifiedInstall