Skip to content
BranchesTags

Repository files navigation

WorkerQueue

WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.

Features

  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives

Prerequisites

  • C++11 or later supported compiler
    • msvc
    • gcc
    • clang
  • CMake (Optional)

Cloning the library

You can clone the library using git. Just run the command as shown below:

 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library

You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.

Compile the library using cmake

 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option

 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:

 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options

OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.

An example:

 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library

You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:

CMakeLists.txt:

cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found

main.cpp:

#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}

Conclusion

If you have any opinions or questions, please do not hesitate to ask me :)

About

Cross platform asynchronous worker queue based on modern C++(11 and later)

Topics

androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool

Resources

Readme
MIT license
Activity

Stars

4 stars

Watchers

2 watching

Forks

1 fork
Report repository

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - kadirlua/WorkerQueue: Cross platform asynchronous worker queue based on modern C++(11 and later) · GitHub
Skip to content
BranchesTags
Repository files navigation
WorkerQueue
WorkerQueue is a lightweight, cross-platform asynchronous task queue for modern C++ (C++11 and later). It allows for concurrent task execution with customizable worker threads.
Features
  • Cross-platform (Windows, Linux, macOS, Android)
  • Asynchronous task queue management
  • Uses modern C++ threading primitives
Prerequisites
  • C++11 or later supported compiler

    • msvc
    • gcc
    • clang
  • CMake (Optional)
Cloning the library
You can clone the library using git. Just run the command as shown below:
 > git clone https://github.com/kadirlua/WorkerQueue.git

Building the library
You can build the library using vcpkg or your own environment. You can use Visual Studio, VSCode or CLion IDEs for building.
Compile the library using cmake
 > mkdir build
> cmake -B build -S .
> cmake --build build

Or with make option
 > mkdir build
> cd build
> cmake ..
> make

If you want to build as static library (default is shared), you can pass the argument as shown below to cmake for configuration:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF

Build options
OptionDescription
BUILD_SHARED_LIBSEnables/disables shared library. Default is ON.
BUILD_EXAMPLES_SRCEnables/disables to build examples source codes. Default is ON.
BUILD_TESTS_SRCEnables/disables to build test source codes. Default is ON.
ENABLE_ASANEnables/disables to build with ASAN support. Default is OFF.
An example:
 > cmake -B build -S . -DBUILD_SHARED_LIBS=OFF -DBUILD_EXAMPLES_SRC=ON -DBUILD_TESTS_SRC=OFF

Use the library
You can use the library into your project. It's easy to integrate into your project using cmake configuration. Insert the necessary codes into your project as shown below:
CMakeLists.txt:
cmake_minimum_required(VERSION3.22.1)
project(TestProject VERSION 1.0 LANGUAGESCXX)
find_package(WorkerQueueREQUIRED) # It's required to find the libraryadd_executable(TestProjectmain.cpp)
target_link_libraries(TestProjectPRIVATEWorkerQueue::WorkerQueue) # link the library if It's found
main.cpp:
#include<iostream>
#include<workerqueue/WorkerQueue.h>intmain()
{
sdk::concurrency::WorkerQueue w1;
w1.push([](){
std::cout << "Test worker message!\n";
});
// wait until all queued and running jobs have finished
w1.wait();
return0;
}
Conclusion
If you have any opinions or questions, please do not hesitate to ask me :)
About
Cross platform asynchronous worker queue based on modern C++(11 and later)
Topics
androidandroid-developmentasynchronous-programmingclangclang-formatclang-tidyclioncmakecpp14cpp17cpp20cross-platformgccmodern-cppmsvcmultithreadingqueuevisual-studiovisual-studio-codeworker-pool
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
2 watching
Forks
1 fork
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages