SiddiqSoft.RWLContainer 1.5.3

RWLContainer : Reader-writer protected containers

Overview

This library provides convenient, production-ready wrappers around C++20 standard library synchronization primitives:

• RWLContainer: A reader-writer lock protected dictionary that wraps std::unordered_map with std::shared_mutex for safe concurrent access
• WaitableQueue: A thread-safe queue that augments std::queue with std::shared_mutex and std::counting_semaphore for efficient producer-consumer patterns

These classes eliminate boilerplate synchronization code and provide a simple, type-safe API for common concurrent programming scenarios.

Requirements

• C++20 or later
• <shared_mutex> and <mutex> support
• CMake 3.20+

Platform Support

Tested and built on:

• Windows (Visual Studio 2022)
• Linux (Fedora)
• macOS

All platforms are tested in the CI/CD pipeline with comprehensive test coverage.

Classes and Methods

RWLContainer

A thread-safe dictionary with reader-writer locking for efficient concurrent access.

RWLContainer<KeyType, StorageType>
├── Configuration
│   ├── ReplaceExisting
│   └── FailOnCollission
├── Methods
│   ├── add(key, value)
│   ├── add(key, shared_ptr)
│   ├── add(key, callback)
│   ├── remove(key)
│   ├── find(key)
│   ├── size()
│   ├── scan(callback)
│   └── toJson()
└── Properties
    ├── addCounter
    └── removeCounter

RWLContainer Methods

WaitableQueue

A thread-safe queue with timeout-based waiting for producer-consumer patterns.

WaitableQueue<StorageType>
├── Methods
│   ├── push(value)
│   ├── emplace(value)
│   ├── tryWaitItem(timeout)
│   ├── waitUntilEmpty(timeout)
│   ├── size()
│   ├── addCounter()
│   ├── removeCounter()
│   └── toJson()
└── Properties
    ├── Deleted: copy constructor
    ├── Deleted: move constructor
    ├── Deleted: copy assignment
    └── Deleted: move assignment

WaitableQueue Methods

API Documentation

For detailed API documentation, method signatures, and comprehensive examples, see API.md and some notes on tests.

Usage

• Use the nuget SiddiqSoft.RWLContainer
• Use CPM to integrate into your CMake project

Quick Example: RWLContainer

#include "siddiqsoft/RWLContainer.hpp"

int main() {
    siddiqsoft::RWLContainer<std::string, int> cache;
    
    // Add items
    cache.add("count", 42);
    cache.add("value", 100);
    
    // Find items
    if (auto val = cache.find("count")) {
        std::cout << "Found: " << *val << std::endl;
    }
    
    // Remove items
    cache.remove("count");
    
    std::cout << "Size: " << cache.size() << std::endl;
    
    return 0;
}

Quick Example: WaitableQueue

#include "siddiqsoft/WaitableQueue.hpp"
#include <thread>

int main() {
    siddiqsoft::WaitableQueue<std::string> queue;
    
    // Producer thread
    std::thread producer([&queue]() {
        for (int i = 0; i < 5; ++i) {
            queue.push(std::string("item_") + std::to_string(i));
        }
    });
    
    // Consumer thread
    std::thread consumer([&queue]() {
        while (true) {
            auto item = queue.tryWaitItem(std::chrono::milliseconds(500));
            if (item) {
                std::cout << "Processed: " << *item << std::endl;
            } else {
                break;
            }
        }
    });
    
    producer.join();
    consumer.join();
    
    return 0;
}

Versioning

Uses GitVersion for semantic versioning (MAJOR.MINOR.PATCH). Version is automatically determined from git history.

<small align="right">

© 2021 Siddiq Software LLC. All rights reserved.

</small>