Sequence.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_SEQUENCE_H_
#define TASKOLIB_SEQUENCE_H_
 
#include <algorithm>
#include <filesystem>
#include <functional>
#include <limits>
#include <optional>
#include <string_view>
#include <string>
#include <utility>
#include <vector>
 
#include <gul17/cat.h>
#include <gul17/finalizer.h>
#include <gul17/traits.h>
 
#include "taskolib/CommChannel.h"
#include "taskolib/Context.h"
#include "taskolib/exceptions.h"
#include "taskolib/SequenceName.h"
#include "taskolib/Step.h"
#include "taskolib/StepIndex.h"
#include "taskolib/Tag.h"
#include "taskolib/TimeoutTrigger.h"
#include "taskolib/UniqueId.h"
 
namespace task {
 
class Sequence
{
public:
    using SizeType = StepIndex;
    using Iterator = std::vector<Step>::iterator;
    using ConstIterator = std::vector<Step>::const_iterator;
    using ConstReverseIterator = std::vector<Step>::const_reverse_iterator;
 
    static constexpr std::size_t max_label_length = 128;
 
    Sequence(std::string_view label = "", SequenceName name = SequenceName{},
        UniqueId uid = UniqueId{});
 
    void assign(ConstIterator iter, const Step& step);
 
    void assign(ConstIterator iter, Step&& step);
 
    ConstIterator begin() const noexcept { return steps_.cbegin(); }
 
    ConstIterator cbegin() const noexcept { return steps_.cbegin(); }
 
    ConstIterator cend() const noexcept { return steps_.cend(); }
 
    ConstReverseIterator crbegin() const noexcept { return steps_.crbegin(); }
 
    ConstReverseIterator crend() const noexcept { return steps_.crend(); }
 
    void check_syntax() const;
 
    bool empty() const noexcept { return steps_.empty(); }
 
    ConstIterator end() const noexcept { return steps_.cend(); }
 
    ConstIterator erase(ConstIterator iter);
 
    ConstIterator erase(ConstIterator begin, ConstIterator end);
 
    [[nodiscard]]
    std::optional<Error> execute(Context& context, CommChannel* comm_channel,
                                   OptionalStepIndex opt_step_index = std::nullopt);
 
    std::optional<Error> get_error() const { return error_; }
 
    std::filesystem::path get_folder() const;
 
    const std::string& get_indentation_error() const noexcept { return indentation_error_; }
 
    const std::string& get_label() const noexcept { return label_; }
 
    const std::string& get_maintainers() const noexcept { return maintainers_; }
 
    const SequenceName& get_name() const noexcept { return name_; }
 
    const std::string& get_step_setup_script() const noexcept { return step_setup_script_; }
 
    const std::vector<Tag>& get_tags() const noexcept { return tags_; }
 
    bool get_autorun() const noexcept { return autorun_; }
 
    bool is_disabled() const noexcept { return is_disabled_; }
 
    TimePoint get_time_of_last_execution() const
    {
        return timeout_trigger_.get_start_time();
    }
 
    Timeout get_timeout() const { return timeout_trigger_.get_timeout(); }
 
    UniqueId get_unique_id() const noexcept { return unique_id_; }
 
    template <typename StepType, std::enable_if_t<
        std::is_same<gul17::remove_cvref_t<StepType>, Step>::value, bool> = true>
    ConstIterator insert(ConstIterator iter, StepType step)
    {
        throw_if_running();
        throw_if_full();
 
        auto return_iter = steps_.insert(iter, std::forward<StepType>(step));
 
        correct_error_index(
            [insert_idx = return_iter - cbegin()](StepIndex error_idx) -> OptionalStepIndex
            {
                if (insert_idx <= error_idx)
                    return error_idx + 1;
                else
                    return error_idx;
            });
 
        enforce_invariants();
        return return_iter;
    }
 
    bool is_running() const noexcept { return is_running_; }
 
    bool is_timeout_elapsed() const { return timeout_trigger_.is_elapsed(); }
 
    static SizeType max_size() noexcept { return std::numeric_limits<StepIndex>::max(); }
 
    template <typename Closure>
    void modify(ConstIterator iter, Closure modification_fct)
    {
        throw_if_running();
 
        // Construct a mutable iterator from the given ConstIterator
        const auto it = steps_.begin() + (iter - steps_.cbegin());
 
        // Reindent at the end of the function, even if an exception is thrown
        auto indent_if_necessary = gul17::finally(
            [this,
             it,
             old_indentation_level = it->get_indentation_level(),
             old_type = it->get_type(),
             old_disabled = it->is_disabled()]()
            {
                if (it->get_type() != old_type
                    || it->get_indentation_level() != old_indentation_level)
                {
                    indent();
                }
 
                // Special treatment for re-enabling an entire block-with-continuation
                // if its head step is re-enabled
                if (it->is_disabled() == false && old_disabled == true)
                {
                    if (it->get_type() == Step::type_if
                        || it->get_type() == Step::type_while
                        || it->get_type() == Step::type_try)
                    {
                        auto it_end = find_end_of_continuation(it);
                        std::for_each(it, it_end, [](Step& st) { st.set_disabled(false); });
                    }
                }
 
                enforce_consistency_of_disabled_flags();
            });
 
        modification_fct(*it);
    }
 
    const Step& operator[](SizeType idx) const noexcept { return steps_[idx]; }
 
    void pop_back();
 
    void push_back(const Step& step);
 
    void push_back(Step&& step);
 
    ConstReverseIterator rbegin() const noexcept { return steps_.crbegin(); }
 
    ConstReverseIterator rend() const noexcept { return steps_.crend(); }
 
    void set_error(std::optional<Error> opt_error);
 
    void set_label(std::string_view label);
 
    void set_maintainers(std::string_view maintainers);
 
    void set_name(SequenceName name) { name_ = std::move(name); }
 
    void set_running(bool running) noexcept { is_running_ = running; }
 
    void set_step_setup_script(std::string_view step_setup_script);
 
    void set_tags(const std::vector<Tag>& tags);
 
    void set_autorun(bool autorun);
 
    void set_disabled(bool disabled = true);
 
    void set_timeout(Timeout timeout) { timeout_trigger_.set_timeout(timeout); }
 
    void set_unique_id(UniqueId uid) { unique_id_ = uid; }
 
    SizeType size() const noexcept { return static_cast<SizeType>(steps_.size()); }
 
private:
    std::optional<Error> error_;
 
    std::string indentation_error_;
 
    UniqueId unique_id_;            
    SequenceName name_;             
    std::string label_;             
    std::string maintainers_;       
    std::string step_setup_script_; 
    std::vector<Tag> tags_;         
    bool autorun_{ false }   ;      
    bool is_disabled_{ false };     
    std::vector<Step> steps_;       
 
    bool is_running_{ false }; 
 
    TimeoutTrigger timeout_trigger_; 
 
    void check_syntax(ConstIterator begin, ConstIterator end) const;
 
    ConstIterator check_syntax_for_if(ConstIterator begin, ConstIterator end) const;
 
    ConstIterator check_syntax_for_try(ConstIterator begin, ConstIterator end) const;
 
    ConstIterator check_syntax_for_while(ConstIterator begin, ConstIterator end) const;
 
    void correct_error_index(
        std::function<OptionalStepIndex(StepIndex err_idx)> get_new_index);
 
    void enforce_consistency_of_disabled_flags() noexcept;
 
    void enforce_invariants();
 
    Iterator
    execute_else_block(Iterator begin, Iterator end, Context& context, CommChannel* comm);
 
    Iterator
    execute_if_or_elseif_block(Iterator begin, Iterator end, Context& context,
                               CommChannel* comm);
 
    Iterator
    execute_range(Iterator step_begin, Iterator step_end, Context& context,
                  CommChannel* comm);
 
    Iterator
    execute_try_block(Iterator begin, Iterator end, Context& context, CommChannel* comm);
 
    Iterator
    execute_while_block(Iterator begin, Iterator end, Context& context, CommChannel* comm);
 
    Iterator find_end_of_continuation(Iterator block_start);
    ConstIterator find_end_of_continuation(ConstIterator block_start) const;
 
    [[nodiscard]]
    std::optional<Error>
    handle_execution(Context& context, CommChannel* comm_channel,
                     std::string_view exec_block_name,
                     std::function<void(Context&, CommChannel*)> runner);
 
    void indent();
 
    void throw_if_full() const;
 
    void throw_if_running() const;
 
    void throw_if_disabled() const;
 
    void throw_syntax_error_for_step(ConstIterator it, std::string_view msg) const;
};
 
} // namespace task
 
#endif