Message.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <chrono>
#include <concepts>
#include <memory>
#include <vector>
 
// Project includes
#include "../MimeType.hpp"
#include "../ports/Kind.hpp"
#include <dfx-utilities/CopyMoveControl.hpp>
#include <dfx-utilities/UUIDGenerator.hpp>
 
namespace dfx::Core
{
class Message;
using MessagePtr = std::unique_ptr<Message>;

template<typename T>
concept DerivedFromMessage = std::derived_from<T, Message>;
 
namespace details
{
class Unpacker;
} // !namespace details

struct blank_construct_t { explicit constexpr blank_construct_t() noexcept = default; };
inline constexpr blank_construct_t blank_construct = blank_construct_t();

class Message
{
    friend class details::Unpacker;
 
public:
    DFX_DISABLE_COPY_AND_MOVE(Message);
    virtual ~Message();


    Utils::UUID const & uuid() const noexcept                   { return _uuid; }
    Utils::UUID const & parentUuid() const noexcept             { return _parentUuid; }
    std::vector<std::string> const & pathTaken() const noexcept { return _pathTaken; }
    std::chrono::microseconds timestamp() const noexcept        { return _timestamp; }


    template<typename Clock = std::chrono::steady_clock>
    requires std::chrono::is_clock_v<Clock>
    std::chrono::time_point<Clock, std::chrono::microseconds> timestampToTimePoint() const noexcept
    { return std::chrono::time_point<Clock, std::chrono::microseconds>(_timestamp); }

    void addToPathTaken(std::string path) { _pathTaken.emplace_back(std::move(path)); }


    bool hasMimeType() const noexcept   { return _mimeType.has_value(); }
    MimeType mimeType() const noexcept  { return _mimeType.value_or(MimeType::OctetStream); }
    void setMimeType(MimeType mimeType);
    void resetMimeType()                { _mimeType.reset(); }


    virtual Kind kind() const = 0;

    virtual MessagePtr clone() const = 0;
 
public:
    template<DerivedFromMessage T>
    bool is() const noexcept { return dynamic_cast<T const *>(this) != nullptr; }

    template<DerivedFromMessage T>
    T & as() noexcept { return static_cast<T &>(*this); }

    template<DerivedFromMessage T>
    T const & as() const noexcept { return static_cast<T const &>(*this); }
 
public:
    template<DerivedFromMessage T, typename ... Args>
    static std::unique_ptr<T> create(Args && ... args)
    { return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); }
 
public:
    static clockid_t timestampClock;
 
protected:
    virtual void cloneFromBase(Message const & base);
 
protected:
    explicit Message(blank_construct_t) noexcept {}

    explicit Message(Message const * parent = nullptr);

    explicit Message(MimeType mimeType, Message const * parent = nullptr);
 
private:
    Utils::UUID               _uuid{};
    Utils::UUID               _parentUuid{};
    std::vector<std::string>  _pathTaken;
    std::chrono::microseconds _timestamp{};
 
private:
    std::optional<MimeType> _mimeType;
};
} // !namespace dfx::Core