Message.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_MESSAGE_H_
#define TASKOLIB_MESSAGE_H_
 
#include <array>
#include <memory>
#include <ostream>
#include <string>
 
#include <gul14/escape.h>
 
#include "taskolib/StepIndex.h"
#include "taskolib/time_types.h"
 
namespace task {
 
class Message
{
public:
    enum class Type
    {
        output, 
        sequence_started, 
        sequence_stopped, 
        sequence_stopped_with_error, 
        step_started, 
        step_stopped, 
        step_stopped_with_error, 
        undefined 
    };
 
private:
    static constexpr std::array<char const*, static_cast<int>(Type::undefined) + 1>
    type_description_ =
    {
        "output",
        "sequence_started",
        "sequence_stopped",
        "sequence_stopped_with_error",
        "step_started",
        "step_stopped",
        "step_stopped_with_error",
        "undefined"
    };
 
 
public:
    Message() = default;
 
    Message(Type type, std::string text, TimePoint timestamp,
            OptionalStepIndex index)
        : text_{ std::move(text) }
        , timestamp_{ timestamp }
        , type_{ type }
        , index_{ index }
    {}
 
    OptionalStepIndex get_index() const { return index_; }
 
    const std::string& get_text() const { return text_; }
 
    Type get_type() const noexcept { return type_; }
 
    TimePoint get_timestamp() const { return timestamp_; };
 
    Message& set_index(OptionalStepIndex index) { index_ = index; return *this; }
 
    Message& set_text(const std::string& text) { text_ = text; return *this; }
 
    Message& set_timestamp(TimePoint timestamp) { timestamp_ = timestamp; return *this; };
 
    Message& set_type(Type type) noexcept { type_ = type; return *this; }
 
    friend std::ostream& operator<<(std::ostream& stream, Type const& t) {
        stream << Message::type_description_[static_cast<int>(t)];
        return stream;
    }
 
    friend std::ostream& operator<<(std::ostream& stream, Message const& mess) {
        stream << "Message{ ";
 
        if (mess.index_.has_value())
            stream << *(mess.index_) << ": ";
 
        stream
            << mess.type_
            << " \""
            << gul14::escape(mess.text_)
            << "\" "
            << to_string(mess.timestamp_)
            << " }\n";
 
        return stream;
    };
 
private:
    std::string text_;
    TimePoint timestamp_{};
    Type type_{ Type::output };
    OptionalStepIndex index_;
};
 
} // namespace task
 
#endif