EventBroadcaster.h

Go to the documentation of this file.

#pragma once
 
#include "tgbot/Types.h"
#include "tgbot/export.h"
 
#include <functional>
#include <initializer_list>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace TgBot {
 
class EventHandler;

class TGBOT_API EventBroadcaster {
    friend EventHandler;
 
public:
    using MessageListener = std::function<void(std::shared_ptr<Message>)>;
    using InlineQueryListener = std::function<void(std::shared_ptr<InlineQuery>)>;
    using ChosenInlineResultListener = std::function<void(std::shared_ptr<ChosenInlineResult>)>;
    using CallbackQueryListener = std::function<void(std::shared_ptr<CallbackQuery>)>;
    using ShippingQueryListener = std::function<void(std::shared_ptr<ShippingQuery>)>;
    using PreCheckoutQueryListener = std::function<void(std::shared_ptr<PreCheckoutQuery>)>;
    using PollListener = std::function<void(std::shared_ptr<Poll>)>;
    using PollAnswerListener = std::function<void(std::shared_ptr<PollAnswer>)>;
    using ChatMemberUpdatedListener = std::function<void(std::shared_ptr<ChatMemberUpdated>)>;
    using ChatJoinRequestListener = std::function<void(std::shared_ptr<ChatJoinRequest>)>;
    using MessageReactionUpdatedListener = std::function<void(std::shared_ptr<MessageReactionUpdated>)>;
    using MessageReactionCountUpdatedListener = std::function<void(std::shared_ptr<MessageReactionCountUpdated>)>;
    using MessageGenerationStoppedListener = std::function<void(std::shared_ptr<MessageGenerationStopped>)>;
    using SuccessfulPaymentListener = std::function<void(std::shared_ptr<Message>, std::shared_ptr<SuccessfulPayment>)>;

    void onAnyMessage(const MessageListener& listener);

    void onCommand(std::string_view commandName, const MessageListener& listener);

    void onCommand(std::initializer_list<std::string_view> commandsList, const MessageListener& listener);

    void onUnknownCommand(const MessageListener& listener);

    void onNonCommandMessage(const MessageListener& listener);

    void onEditedMessage(const MessageListener& listener);

    void onInlineQuery(const InlineQueryListener& listener);

    void onChosenInlineResult(const ChosenInlineResultListener& listener);

    void onCallbackQuery(const CallbackQueryListener& listener);

    void onShippingQuery(const ShippingQueryListener& listener);

    void onPreCheckoutQuery(const PreCheckoutQueryListener& listener);

    void onPoll(const PollListener& listener);

    void onPollAnswer(const PollAnswerListener& listener);

    void onMyChatMember(const ChatMemberUpdatedListener& listener);

    void onChatMember(const ChatMemberUpdatedListener& listener);

    void onChatJoinRequest(const ChatJoinRequestListener& listener);

    void onMessageReaction(const MessageReactionUpdatedListener& listener);

    void onMessageReactionCount(const MessageReactionCountUpdatedListener& listener);

    void onMessageGenerationStopped(const MessageGenerationStoppedListener& listener);

    void onSuccessfulPayment(const SuccessfulPaymentListener& listener);
 
private:
    struct TransparentStringHash {
        using is_transparent = void;
 
        std::size_t operator()(std::string_view value) const noexcept {
            return std::hash<std::string_view> { }(value);
        }
    };
 
    template<typename ListenerType, typename ObjectType>
    void broadcast(const std::vector<ListenerType>& listeners, ObjectType object) const;
 
    void broadcastAnyMessage(const std::shared_ptr<Message>& message) const;
    bool broadcastCommand(std::string_view command, const std::shared_ptr<Message>& message) const;
    void broadcastUnknownCommand(const std::shared_ptr<Message>& message) const;
    void broadcastNonCommandMessage(const std::shared_ptr<Message>& message) const;
    void broadcastEditedMessage(const std::shared_ptr<Message>& message) const;
    void broadcastInlineQuery(const std::shared_ptr<InlineQuery>& query) const;
    void broadcastChosenInlineResult(const std::shared_ptr<ChosenInlineResult>& result) const;
    void broadcastCallbackQuery(const std::shared_ptr<CallbackQuery>& result) const;
    void broadcastShippingQuery(const std::shared_ptr<ShippingQuery>& result) const;
    void broadcastPreCheckoutQuery(const std::shared_ptr<PreCheckoutQuery>& result) const;
    void broadcastPoll(const std::shared_ptr<Poll>& result) const;
    void broadcastPollAnswer(const std::shared_ptr<PollAnswer>& result) const;
    void broadcastMyChatMember(const std::shared_ptr<ChatMemberUpdated>& result) const;
    void broadcastChatMember(const std::shared_ptr<ChatMemberUpdated>& result) const;
    void broadcastChatJoinRequest(const std::shared_ptr<ChatJoinRequest>& result) const;
    void broadcastMessageReactionUpdated(const std::shared_ptr<MessageReactionUpdated>& messageReaction) const;
    void broadcastMessageReactionCountUpdated(
        const std::shared_ptr<MessageReactionCountUpdated>& messageReactionCount) const;
    void
    broadcastMessageGenerationStopped(const std::shared_ptr<MessageGenerationStopped>& messageGenerationStopped) const;
    void broadcastSuccessfulPayment(const std::shared_ptr<Message>& message) const;
 
    std::vector<MessageListener> _onAnyMessageListeners;
    std::unordered_map<std::string, MessageListener, TransparentStringHash, std::equal_to<>> _onCommandListeners;
    std::vector<MessageListener> _onUnknownCommandListeners;
    std::vector<MessageListener> _onNonCommandMessageListeners;
    std::vector<MessageListener> _onEditedMessageListeners;
    std::vector<InlineQueryListener> _onInlineQueryListeners;
    std::vector<ChosenInlineResultListener> _onChosenInlineResultListeners;
    std::vector<CallbackQueryListener> _onCallbackQueryListeners;
    std::vector<ShippingQueryListener> _onShippingQueryListeners;
    std::vector<PreCheckoutQueryListener> _onPreCheckoutQueryListeners;
    std::vector<PollListener> _onPollListeners;
    std::vector<PollAnswerListener> _onPollAnswerListeners;
    std::vector<ChatMemberUpdatedListener> _onMyChatMemberListeners;
    std::vector<ChatMemberUpdatedListener> _onChatMemberListeners;
    std::vector<ChatJoinRequestListener> _onChatJoinRequestListeners;
    std::vector<MessageReactionUpdatedListener> _onMessageReactionUpdatedListener;
    std::vector<MessageReactionCountUpdatedListener> _onMessageReactionCountUpdatedListener;
    std::vector<MessageGenerationStoppedListener> _onMessageGenerationStoppedListeners;
    std::vector<SuccessfulPaymentListener> _onSuccessfulPaymentListeners;
};
 
} // namespace TgBot