flags.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/color.hpp>
#include <commons/display_info.hpp>
#include <commons/flag.hpp>
#include <commons/icon.hpp>
#include <commons/icons.hpp>
 
namespace conduit::flags {
 
struct ConduitFlagCategory : comms::FlagCategory<"conduit"> {};
 
template <comms::FixedString Name, typename Category = ConduitFlagCategory>
using Flag = comms::Flag<Name, Category>;
 
using FlagSet = comms::FlagSet;
 
// ---------------------------------------------------------------------------
// Built-in flag tag types. Each carries a `DisplayInfo` (mdi icon + Colors::mui
// palette color) and is registered with the `comms::GlobalFlagRegistry` so its
// wire-name round-trips through `parcel::FlagSetCell`.
// ---------------------------------------------------------------------------
 
struct Direct : Flag<"direct"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "Direct",
            .description = "Force same-thread dispatch even in Queue / ThreadPool execution modes.",
            .icon = comms::Icons::mdi::flash,
            .color = comms::Colors::mui::yellow_700,
        };
        return info;
    }
};
 
struct Durable : Flag<"durable"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "Durable",
            .description = "Hint to durable transports that they should persist the envelope.",
            .icon = comms::Icons::mdi::database,
            .color = comms::Colors::mui::blue_700,
        };
        return info;
    }
};
 
struct Persistent : Flag<"persistent"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "Persistent",
            .description = "Hint to transports to use a persistent (human-readable) wire format.",
            .icon = comms::Icons::mdi::file_document_outline,
            .color = comms::Colors::mui::teal_500,
        };
        return info;
    }
};
 
struct NoMiddleware : Flag<"no_middleware"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "NoMiddleware",
            .description = "Skip the middleware pipeline for this envelope.",
            .icon = comms::Icons::mdi::pipe_disconnected,
            .color = comms::Colors::mui::grey_600,
        };
        return info;
    }
};
 
struct RequireAck : Flag<"require_ack"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "RequireAck",
            .description =
                "Request the broker / transport acknowledge the publish before returning.",
            .icon = comms::Icons::mdi::check_decagram,
            .color = comms::Colors::mui::green_600,
        };
        return info;
    }
};
 
struct Broadcast : Flag<"broadcast"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "Broadcast",
            .description = "Hint that this envelope is intended for fan-out broadcast.",
            .icon = comms::Icons::mdi::broadcast,
            .color = comms::Colors::mui::deep_orange_500,
        };
        return info;
    }
};
 
struct LocalOnly : Flag<"local_only"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "LocalOnly",
            .description = "Restrict dispatch to transports with TransportScope::Local.",
            .icon = comms::Icons::mdi::home_circle,
            .color = comms::Colors::mui::light_blue_500,
        };
        return info;
    }
};
 
struct RemoteOnly : Flag<"remote_only"> {
    static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "RemoteOnly",
            .description = "Restrict dispatch to transports with TransportScope::Remote.",
            .icon = comms::Icons::mdi::earth,
            .color = comms::Colors::mui::indigo_500,
        };
        return info;
    }
};
 
// Self-register the built-ins so `parcel::FlagSetCell` can resolve them by name
// on decode and so `GlobalFlagRegistry::find("direct")` etc. just work.
COMMONS_REGISTER_FLAG(Direct);
COMMONS_REGISTER_FLAG(Durable);
COMMONS_REGISTER_FLAG(Persistent);
COMMONS_REGISTER_FLAG(NoMiddleware);
COMMONS_REGISTER_FLAG(RequireAck);
COMMONS_REGISTER_FLAG(Broadcast);
COMMONS_REGISTER_FLAG(LocalOnly);
COMMONS_REGISTER_FLAG(RemoteOnly);
 
}  // namespace conduit::flags