client.hh

Go to the documentation of this file.

#ifndef __OPERATOR_CLIENT_HH_
#define __OPERATOR_CLIENT_HH_

#include "structs.hh"
#include "event.hh"

#include <memory>
#include <string>
#include <map>
#include <list>
#include <set>

namespace Operator {
  namespace Client {
    class Client {
    public:
      Client();

      class Room {
      public:
        Room(Client &c, const std::string &_id, Event::RoomMembership::membership_t _membership)
          : client(c), id(_id), membership(_membership) {}

        const std::string &getID() const { return id; }
        Event::RoomMembership::membership_t getMembership() const { return membership; }

        void on(const std::string &type, const callback_t<Room &, const Event::Event &> &);

      protected:
        Client &client;
        std::string id;
        Event::RoomMembership::membership_t membership;
        std::map<std::string, nlohmann::json> state;
        std::map<std::string, std::list<callback_t<Room &, const Event::Event &> > > listeners;

        friend class ::Operator::Client::Client;
      };

      virtual ~Client() {}

      virtual void login(const std::string &username, const std::string &password, const callback_t<const std::string &,const std::string &> & = noop_callback<const std::string &,const std::string &>) = 0;

      virtual void loginWith3PID(const std::string &medium, const std::string &address, const std::string &password, const callback_t<const std::string &,const std::string &> & = noop_callback<const std::string &,const std::string &>) = 0;

      virtual void logout(const callback_t<> & = noop_callback<>) = 0;

      virtual bool isLoggedIn() const = 0;

      virtual void startClient() = 0;
      virtual void stopClient() = 0;

      virtual void sendMessage(const Event::MessageEvent &message, const callback_t<const std::string &> &callback = noop_callback<const std::string &>) = 0;

      Room &getRoom(const std::string &room_id) {
        auto room_it = rooms.find(room_id);
        if (room_it != rooms.end())
        {
          return room_it->second;
        }
        else
        {
          rooms.emplace(room_id, Room(*this, room_id, Event::RoomMembership::NONE));
        }
      }
      const Room &getRoom(const std::string &room_id) const throw (std::out_of_range) {
        return rooms.at(room_id);
      }

      Room &operator[](const std::string &room_id) {
        return getRoom(room_id);
      }
      const Room &operator[](const std::string &room_id) const throw (std::out_of_range) {
        return getRoom(room_id);
      }

      void on(const std::string &type, const callback_t<Room &, const Event::Event &> &callback);
      template <class T> inline void on(const callback_t<Room &, const Event::Event &> &callback) { on(T::TYPE, callback); }
    protected:
      void trigger(const Event::Event &event);
      void triggerError(const std::string &event_type, std::shared_ptr<Error::Error> error, const std::string &room_id = "");
      std::map<std::string, Room> rooms;

      void _setRoomMembership(Room &room, Event::RoomMembership::membership_t membership) {
        room.membership = membership;
      }
    private:
      std::map<std::string, std::list<callback_t<Room &, const Event::Event &> > > listeners;
    };

    inline Client &operator<<(Client &client, const Event::MessageEvent &message) {
      client.sendMessage(message, noop_callback<const std::string &>);
      return client;
    }
  }
}

#endif // __OPERATOR_CLIENT_HH_