Smart_Store API Guide: Threading for High-Performance Item Management

Modern applications rarely run in isolation. They often need to handle multiple users, concurrent requests, and heavy workloads—all without sacrificing reliability. In C++, this challenge is magnified by the complexity of managing shared resources safely. Smart_Store rises to the occasion with a robust multithreading model that ensures smooth, efficient, and safe operations.

Why Threading Matters in Smart_Store
Smart_Store’s threading architecture is designed to keep the system responsive and reliable, even under heavy load or in multi-user environments. By leveraging internal mutexes and thread-safe APIs, Smart_Store guarantees:

• Concurrent access without corruption
• Performance boosts during bulk operations
• Safe shared object management
• Scalability for multi-user systems

Example: Simulating Concurrent Users

// Simple thread simulation with ItemManager
void simulateUser(ItemManager& manager, int userId) {
    auto itemName = "Item_" + std::to_string(userId);
    auto item = std::make_shared<Item>(Item{itemName});
    manager.addItem(item, "user_tag_" + std::to_string(userId));
    manager.hasItem("user_tag_" + std::to_string(userId));
}

This example demonstrates how multiple threads can safely add items concurrently without data corruption.

Real-World Use Case: Employee Registration System
Beyond simple simulations, Smart_Store threading shines in real-world applications. Consider a scenario where multiple employees are registered simultaneously in a store’s system:

// Include Smart_Store's item management system
#include "t_manager/ItemManager.h"
#include "err_log/Logger.hpp"
#include <iostream>
#include <vector>
#include <thread>
#include <string>
#include <nlohmann/json.hpp>  // For JSON serialization

// Define a User class to represent employees
class User {
public:
    std::string name;
    int id;
    std::string email;
    std::string role;
    int age;

    User(const std::string& name, int id, const std::string& email, const std::string& role, int age)
        : name(name), id(id), email(email), role(role), age(age) {}
    User() : name(""), id(0), email(""), role(""), age(0) {}

    nlohmann::json toJson() const {
        return { {"name", name}, {"id", id}, {"email", email}, {"role", role}, {"age", age} };
    }

    static User fromJson(const nlohmann::json& j) {
        return User(j.at("name"), j.at("id"), j.at("email"), j.at("role"), j.at("age"));
    }
};

// Function to add a User concurrently
void addEmployee(ItemManager& manager, int id) {
    auto user = std::make_shared<User>(
        "User_" + std::to_string(id),
        id,
        "user" + std::to_string(id) + "@store.com",
        "Staff",
        20 + (id % 10)
    );
    manager.addItem(user, "emp_" + std::to_string(id));
}

int main() {
    ItemManager manager;
    std::vector<std::thread> threads;

    // Spawn 3 threads to simulate concurrent employee registration
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(addEmployee, std::ref(manager), i);
    }

    for (auto& t : threads) t.join();

    std::cout << "All employees added.\n";

    // Retrieve and display employee with tag "emp_1"
    auto importedUser = manager.getItem<User>("emp_1");
    LOG_CONTEXT(LogLevel::DISPLAY, "\n" + importedUser->toJson().dump(4), {});

    // Modify employee email
    manager.modifyItem<User>("emp_1", [](User& user) {
        user.email = "[e-mail]";
    });

    // Display updated employee data
    importedUser = manager.getItem<User>("emp_1");
    LOG_CONTEXT(LogLevel::DISPLAY, "\n" + importedUser->toJson().dump(4), {});

    return 0;
}

Expected Output

Final Thoughts
This real-world threading example demonstrates how Smart_Store can safely handle concurrent employee registrations, serialize data to JSON, and even modify records—all without race conditions or corruption. It’s a powerful showcase of how Smart_Store threading translates from theory to practice.

Explore the full repository: Smart_Store