Content Management System. More...

Collaboration diagram for scenarios::ContentManagementSystem:

Classes
struct	Document

Public Member Functions
void	simulate_cms_scenario ()

Private Member Functions
std::string	generate_sample_content (int index)

void	process_document (const Document &document)

void	create_search_index_entry (const Document &document)

size_t	count_words (const std::string &text)

Private Attributes
std::atomic< int >	documents_processed_ {0}

std::atomic< int >	documents_indexed_ {0}

Detailed Description

Content Management System.

Examples: real_world_scenarios.cpp.

Definition at line 482 of file real_world_scenarios.cpp.

Member Function Documentation

◆ count_words()

size_t scenarios::ContentManagementSystem::count_words ( const std::string & text )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 615 of file real_world_scenarios.cpp.

                                              {
        std::istringstream iss(text);
        std::string word;
        size_t count = 0;
        while (iss >> word) {
            count++;
        }
        return count;
    }

Referenced by create_search_index_entry().

Here is the caller graph for this function:

◆ create_search_index_entry()

void scenarios::ContentManagementSystem::create_search_index_entry ( const Document & document )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 598 of file real_world_scenarios.cpp.

                                                             {
        auto index_container = std::make_shared<value_container>();
        index_container->set_source("text_analyzer", "indexing_service");
        index_container->set_target("search_service", "index_updater");
        index_container->set_message_type("search_index_update");
 
        index_container->set("document_id", document.document_id);
        index_container->set("indexed_title", document.title);
        index_container->set("indexed_category", document.category);
        index_container->set("word_count", static_cast<int32_t>(count_words(document.content)));
        index_container->set("index_timestamp", static_cast<int64_t>(
            std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::system_clock::now().time_since_epoch()).count()));
 
        index_container->serialize_string(value_container::serialization_format::binary).value();
    }

References scenarios::ContentManagementSystem::Document::category, scenarios::ContentManagementSystem::Document::content, count_words(), scenarios::ContentManagementSystem::Document::document_id, and scenarios::ContentManagementSystem::Document::title.

Referenced by process_document().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_sample_content()

std::string scenarios::ContentManagementSystem::generate_sample_content ( int index )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 561 of file real_world_scenarios.cpp.

                                                 {
        std::stringstream content;
        content << "This is sample content for document " << index << ". ";
        content << "It contains important information for demonstration purposes.";
        return content.str();
    }

Referenced by simulate_cms_scenario().

Here is the caller graph for this function:

◆ process_document()

void scenarios::ContentManagementSystem::process_document ( const Document & document )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 568 of file real_world_scenarios.cpp.

                                                    {
        auto container = std::make_shared<value_container>();
        container->set_source("cms_upload_service", "document_processor");
        container->set_target("search_indexer", "text_analyzer");
        container->set_message_type("document_processing");
 
        container->set("document_id", document.document_id);
        container->set("title", document.title);
        container->set("author", document.author);
        container->set("category", document.category);
        container->set("content_length", static_cast<int32_t>(document.content.length()));
        container->set("upload_timestamp", static_cast<int64_t>(
            std::chrono::duration_cast<std::chrono::milliseconds>(
                document.upload_time.time_since_epoch()).count()));
        container->set("tag_count", static_cast<int32_t>(document.tags.size()));
        container->set("content", document.content);
 
        for (size_t i = 0; i < document.tags.size(); ++i) {
            container->set("tag_" + std::to_string(i), document.tags[i]);
        }
 
        container->serialize_string(value_container::serialization_format::binary).value();
        create_search_index_entry(document);
        documents_indexed_++;
 
        if (documents_processed_ % 20 == 0) {
            std::cout << "  Processed " << documents_processed_.load() << " documents..." << std::endl;
        }
    }

References scenarios::ContentManagementSystem::Document::author, scenarios::ContentManagementSystem::Document::category, scenarios::ContentManagementSystem::Document::content, create_search_index_entry(), scenarios::ContentManagementSystem::Document::document_id, documents_indexed_, documents_processed_, scenarios::ContentManagementSystem::Document::tags, scenarios::ContentManagementSystem::Document::title, and scenarios::ContentManagementSystem::Document::upload_time.

Referenced by simulate_cms_scenario().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simulate_cms_scenario()

void scenarios::ContentManagementSystem::simulate_cms_scenario ( )

inline

Examples: real_world_scenarios.cpp.

Definition at line 498 of file real_world_scenarios.cpp.

                                 {
        std::cout << "\n=== Content Management System Scenario ===" << std::endl;
 
        const int num_documents = 50;
 
        std::queue<Document> document_queue;
        std::mutex document_mutex;
        std::condition_variable document_cv;
        std::atomic<bool> uploading_active{true};
 
        std::thread document_processor([&]() {
            while (uploading_active || !document_queue.empty()) {
                std::unique_lock<std::mutex> lock(document_mutex);
                document_cv.wait(lock, [&]() { return !document_queue.empty() || !uploading_active; });
 
                if (!document_queue.empty()) {
                    Document document = document_queue.front();
                    document_queue.pop();
                    lock.unlock();
 
                    process_document(document);
                    documents_processed_++;
                }
            }
        });
 
        std::vector<std::string> categories = {"article", "report", "manual"};
        std::vector<std::string> authors = {"john_smith", "jane_doe", "bob_wilson"};
        std::vector<std::vector<std::string>> tag_sets = {
            {"programming", "cpp", "tutorial"},
            {"business", "report", "analysis"},
            {"technical", "manual", "guide"}
        };
 
        for (int i = 0; i < num_documents; ++i) {
            Document document;
            document.document_id = "DOC" + std::to_string(10000 + i);
            document.title = "Document Title " + std::to_string(i);
            document.content = generate_sample_content(i);
            document.author = authors[i % authors.size()];
            document.category = categories[i % categories.size()];
            document.tags = tag_sets[i % tag_sets.size()];
            document.upload_time = std::chrono::system_clock::now();
 
            {
                std::lock_guard<std::mutex> lock(document_mutex);
                document_queue.push(document);
            }
            document_cv.notify_one();
 
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
 
        uploading_active = false;
        document_cv.notify_all();
        document_processor.join();
 
        std::cout << "CMS simulation completed:" << std::endl;
        std::cout << "  Documents processed: " << documents_processed_.load() << std::endl;
        std::cout << "  Documents indexed: " << documents_indexed_.load() << std::endl;
    }