patch/docs/_event_broadcaster_8h_source.html

 /*
  * Copyright (c) 2015 Oleg Morozenkov
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */

 #ifndef TGBOT_EVENTBROADCASTER_H
 #define TGBOT_EVENTBROADCASTER_H

 #include <string>
 #include <functional>
 #include <vector>
 #include <unordered_map>

 #include "tgbot/types/Message.h"
 #include "tgbot/types/InlineQuery.h"
 #include "tgbot/types/ChosenInlineResult.h"
 #include "tgbot/types/CallbackQuery.h"

 namespace TgBot {

 class EventHandler;

 class EventBroadcaster {

 friend EventHandler;

 public:
     typedef std::function<void (const Message::Ptr)> MessageListener;
     typedef std::function<void (const InlineQuery::Ptr)> InlineQueryListener;
     typedef std::function<void (const ChosenInlineResult::Ptr)> ChosenInlineResultListener;
     typedef std::function<void (const CallbackQuery::Ptr)> CallbackQueryListener;

     inline void onAnyMessage(const MessageListener& listener) {
         _onAnyMessageListeners.push_back(listener);
     }

     inline void onCommand(const std::string& commandName, const MessageListener& listener) {
         _onCommandListeners[commandName] = listener;
     }

     inline void onCommand(const std::initializer_list<std::string>& commandsList, const MessageListener& listener) {
         for (const auto& command : commandsList)
         {
             _onCommandListeners[command] = listener;
         }
     }

     inline void onUnknownCommand(const MessageListener& listener) {
         _onUnknownCommandListeners.push_back(listener);
     }

     inline void onNonCommandMessage(const MessageListener& listener) {
         _onNonCommandMessageListeners.push_back(listener);
     }

     inline void onInlineQuery(const InlineQueryListener& listener) {
         _onInlineQueryListeners.push_back(listener);
     }

     inline void onChosenInlineResult(const ChosenInlineResultListener& listener){
         _onChosenInlineResultListeners.push_back(listener);
     }

     inline void onCallbackQuery(const CallbackQueryListener& listener){
         _onCallbackQueryListeners.push_back(listener);
     }

 private:
     template<typename ListenerType, typename ObjectType>
     inline void broadcast(const std::vector<ListenerType>& listeners, const ObjectType object) const {
         if (!object)
             return;

         for (const ListenerType& item : listeners) {
             item(object);
         }
     }

     inline void broadcastAnyMessage(const Message::Ptr message) const {
         broadcast<MessageListener, Message::Ptr>(_onAnyMessageListeners, message);
     }

     inline bool broadcastCommand(const std::string command, const Message::Ptr message) const {
         std::unordered_map<std::string, MessageListener>::const_iterator iter = _onCommandListeners.find(command);
         if (iter == _onCommandListeners.end()) {
             return false;
         }
         iter->second(message);
         return true;
     }

     inline void broadcastUnknownCommand(const Message::Ptr message) const {
         broadcast<MessageListener, Message::Ptr>(_onUnknownCommandListeners, message);
     }

     inline void broadcastNonCommandMessage(const Message::Ptr message) const {
         broadcast<MessageListener, Message::Ptr>(_onNonCommandMessageListeners, message);
     }

     inline void broadcastInlineQuery(const InlineQuery::Ptr query) const {
         broadcast<InlineQueryListener, InlineQuery::Ptr>(_onInlineQueryListeners, query);
     }

     inline void broadcastChosenInlineResult(const ChosenInlineResult::Ptr result) const {
         broadcast<ChosenInlineResultListener, ChosenInlineResult::Ptr>(_onChosenInlineResultListeners, result);
     }

     inline void broadcastCallbackQuery(const CallbackQuery::Ptr result) const {
         broadcast<CallbackQueryListener, CallbackQuery::Ptr>(_onCallbackQueryListeners, result);
     }

     std::vector<MessageListener> _onAnyMessageListeners;
     std::unordered_map<std::string, MessageListener> _onCommandListeners;
     std::vector<MessageListener> _onUnknownCommandListeners;
     std::vector<MessageListener> _onNonCommandMessageListeners;
     std::vector<InlineQueryListener> _onInlineQueryListeners;
     std::vector<ChosenInlineResultListener> _onChosenInlineResultListeners;
     std::vector<CallbackQueryListener> _onCallbackQueryListeners;
 };

 }

 #endif //TGBOT_EVENTBROADCASTER_H
TgBot::EventBroadcaster::onAnyMessage
void onAnyMessage(const MessageListener &listener)
Registers listener which receives all messages which the bot can ever receive.
Definition: EventBroadcaster.h:59

-TgBot::EventBroadcaster
This class holds all event listeners.
Definition: EventBroadcaster.h:45

-TgBot::CallbackQuery::Ptr
std::shared_ptr< CallbackQuery > Ptr
Definition: CallbackQuery.h:22

-TgBot
Definition: Api.h:49

-CallbackQuery.h

-TgBot::EventBroadcaster::CallbackQueryListener
std::function< void(const CallbackQuery::Ptr)> CallbackQueryListener
Definition: EventBroadcaster.h:53

-InlineQuery.h

-TgBot::Message::Ptr
std::shared_ptr< Message > Ptr
Definition: Message.h:56

-TgBot::EventHandler
Definition: EventHandler.h:32

-TgBot::ChosenInlineResult::Ptr
std::shared_ptr< ChosenInlineResult > Ptr
Definition: ChosenInlineResult.h:23

-TgBot::EventBroadcaster::onInlineQuery
void onInlineQuery(const InlineQueryListener &listener)
Registers listener which receives all the inline query.
Definition: EventBroadcaster.h:104

-TgBot::EventBroadcaster::onCallbackQuery
void onCallbackQuery(const CallbackQueryListener &listener)
Definition: EventBroadcaster.h:116

-TgBot::EventBroadcaster::ChosenInlineResultListener
std::function< void(const ChosenInlineResult::Ptr)> ChosenInlineResultListener
Definition: EventBroadcaster.h:52

-TgBot::EventBroadcaster::onUnknownCommand
void onUnknownCommand(const MessageListener &listener)
Registers listener which receives all messages with commands (messages with leading &#39;/&#39; char) which h...
Definition: EventBroadcaster.h:88

-TgBot::EventBroadcaster::onCommand
void onCommand(const std::string &commandName, const MessageListener &listener)
Registers listener which receives all messages with commands (messages with leading &#39;/&#39; char)...
Definition: EventBroadcaster.h:68

-TgBot::EventBroadcaster::InlineQueryListener
std::function< void(const InlineQuery::Ptr)> InlineQueryListener
Definition: EventBroadcaster.h:51

-TgBot::EventBroadcaster::onCommand
void onCommand(const std::initializer_list< std::string > &commandsList, const MessageListener &listener)
Registers listener which receives all messages with commands (messages with leading &#39;/&#39; char)...
Definition: EventBroadcaster.h:77

-TgBot::EventBroadcaster::onNonCommandMessage
void onNonCommandMessage(const MessageListener &listener)
Registers listener which receives all messages without commands (messages with no leading &#39;/&#39; char) ...
Definition: EventBroadcaster.h:96

-ChosenInlineResult.h

-TgBot::EventBroadcaster::onChosenInlineResult
void onChosenInlineResult(const ChosenInlineResultListener &listener)
Registers listener which receives all the chosen inline result.
Definition: EventBroadcaster.h:112

-TgBot::InlineQuery::Ptr
std::shared_ptr< InlineQuery > Ptr
Definition: InlineQuery.h:23

-TgBot::EventBroadcaster::MessageListener
std::function< void(const Message::Ptr)> MessageListener
Definition: EventBroadcaster.h:50

-Message.h

-