Step.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_STEP_H_
#define TASKOLIB_STEP_H_
 
#include <chrono>
#include <set>
#include <string>
 
#include "taskolib/CommChannel.h"
#include "taskolib/Context.h"
#include "taskolib/time_types.h"
#include "taskolib/Timeout.h"
#include "taskolib/TimeoutTrigger.h"
#include "taskolib/VariableName.h"
 
namespace task {
 
using VariableNames = std::set<VariableName>;
 
class Step
{
public:
    enum Type
    {
        type_action, type_if, type_else, type_elseif, type_end, type_while, type_try,
        type_catch
    };
 
    static constexpr short max_indentation_level{ 20 };
 
 
    explicit Step(Type type = type_action)
        : type_{ type }
    {}
 
    bool execute(Context& context, CommChannel* comm_channel = nullptr,
                 OptionalStepIndex opt_step_index = gul14::nullopt,
                 TimeoutTrigger* sequence_timeout = nullptr);
 
    const VariableNames& get_used_context_variable_names() const
    {
        return used_context_variable_names_;
    }
 
    short get_indentation_level() const noexcept { return indentation_level_; }
 
    const std::string& get_label() const { return label_; }
 
    const std::string& get_script() const { return script_; }
 
    TimePoint get_time_of_last_execution() const { return time_of_last_execution_; }
 
    TimePoint get_time_of_last_modification() const { return time_of_last_modification_; }
 
    Timeout get_timeout() const { return timeout_; }
 
    Type get_type() const noexcept { return type_; }
 
    bool is_running() const noexcept { return is_running_; }
 
    bool is_disabled() const noexcept { return is_disabled_; }
 
    Step& set_disabled(bool disable);
 
    Step& set_indentation_level(short level);
 
    Step& set_label(const std::string& label);
 
    Step& set_running(bool is_running);
 
    Step& set_script(const std::string& script);
 
    Step& set_time_of_last_execution(TimePoint t);
 
    Step& set_time_of_last_modification(TimePoint t);
 
    Step& set_timeout(Timeout timeout);
 
    Step& set_type(Type type);
 
    Step& set_used_context_variable_names(const VariableNames& used_context_variable_names);
    Step& set_used_context_variable_names(VariableNames&& used_context_variable_names);
 
private:
    std::string label_;
    std::string script_;
    VariableNames used_context_variable_names_;
    TimePoint time_of_last_modification_{ Clock::now() };
    TimePoint time_of_last_execution_;
    Timeout timeout_;
    Type type_{ type_action };
    short indentation_level_{ 0 };
    bool is_running_{ false };
    bool is_disabled_{ false };
 
    void copy_used_variables_from_context_to_lua(const Context& context, sol::state& lua);
 
    void copy_used_variables_from_lua_to_context(const sol::state& lua, Context& context);
 
    bool execute_impl(Context& context, CommChannel* comm_channel
        , OptionalStepIndex index, TimeoutTrigger* sequence_timeout);
};
 
using ExecutionSteps = std::set<Step::Type>;
 
const ExecutionSteps execution_steps{
    Step::type_action,
    Step::type_if,
    Step::type_elseif,
    Step::type_while
    };
 
std::string to_string(Step::Type type);
 
bool executes_script(Step::Type step_type);
 
bool requires_bool_return_value(Step::Type step_type) noexcept;
 
} // namespace task
 
#endif