scriptModules.hpp

Go to the documentation of this file.

/*
 * Copyright (c) <2026> Anthony J. Greenberg
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */


 
#pragma once
 
#include <string>
#include <condition_variable>
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <filesystem>
 
namespace PSSspace {
    using MessageTranslator = std::function<std::string(const std::string &messageId, const std::string &argument)>;
    void setMessageTranslator(MessageTranslator translator);
    [[nodiscard]] std::string translateMessage(const std::string &messageId, const std::string &argument);
    [[nodiscard]] std::string runScript(const std::filesystem::path &script);
    void truncateUtf8(std::string &text, size_t maxCodepoints);
    class TimedModule {
    public:
        TimedModule() = default;
        TimedModule(
            const std::chrono::duration<uint32_t> &executionInterval,
            std::shared_ptr<std::condition_variable> stopSignal,
            std::shared_ptr<std::mutex> mutex,
            std::shared_ptr<bool> stop,
            std::unique_ptr<std::condition_variable> signalOnChange,
            const std::filesystem::path &script,
            const size_t &outputLengthLimit,
            std::unique_ptr<std::string> outputTarget
        ) : refreshInterval_{executionInterval},
            stopSignal_{std::move(stopSignal)},
            mutex_{std::move(mutex)},
            stop_{std::move(stop)},
            signalToMain_{std::move(signalOnChange)},
            script_{script},
            outputLengthLimit_{outputLengthLimit},
            outputString_{std::move(outputTarget)} {};

        TimedModule(TimedModule &&toMove) noexcept = default;
        TimedModule& operator=(TimedModule &&toMove) noexcept = default;
        ~TimedModule() = default;
        void operator()() const;
    private:
        std::chrono::duration<uint32_t> refreshInterval_;
        std::shared_ptr<std::condition_variable> stopSignal_;
        std::shared_ptr<std::mutex> mutex_;
        std::shared_ptr<bool> stop_;
        std::unique_ptr<std::condition_variable> signalToMain_;
        std::filesystem::path script_;
        size_t outputLengthLimit_ = 0;
        std::unique_ptr<std::string> outputString_;
    };

    class SignalModule {
    public:
        SignalModule() = default;
        SignalModule(
            std::unique_ptr<std::condition_variable> signalToExecute,
            std::shared_ptr<std::mutex> mutex,
            std::shared_ptr<bool> execute,
            std::shared_ptr<bool> stop,
            std::unique_ptr<std::condition_variable> signalOnChange,
            const std::filesystem::path &script,
            const size_t &outputLengthLimit,
            std::unique_ptr<std::string> &outputTarget
        ) : executionSignal_{std::move(signalToExecute)},
            mutex_{std::move(mutex)},
            execute_{std::move(execute)},
            stop_{std::move(stop)},
            signalToMain_{std::move(signalOnChange)},
            script_{script},
            outputLengthLimit_{outputLengthLimit},
            outputString_{std::move(outputTarget)} {};

        SignalModule(SignalModule &&toMove) noexcept = default;
        SignalModule& operator=(SignalModule &&toMove) noexcept = default;
        ~SignalModule() = default;
        void operator()() const;
    private:
        std::unique_ptr<std::condition_variable> executionSignal_;
        std::shared_ptr<std::mutex> mutex_;
        std::shared_ptr<bool> execute_;
        std::shared_ptr<bool> stop_;
        std::unique_ptr<std::condition_variable> signalToMain_;
        std::filesystem::path script_;
        size_t outputLengthLimit_ = 0;
        std::unique_ptr<std::string> outputString_;
    };
}