1 files changed, 10 insertions, 5 deletions
diff --git a/Sluift/SluiftClient.h b/Sluift/SluiftClient.h
index a48c681..ac4c582 100644
--- a/Sluift/SluiftClient.h
+++ b/Sluift/SluiftClient.h
@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2013-2017 Isode Limited.
+ * Copyright (c) 2013-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <deque>
 
 #include <boost/bind.hpp>
@@ -39,35 +39,38 @@ namespace Swift {
 
     class SluiftClient {
         public:
             struct Event {
                 enum Type {
                     MessageType,
                     PresenceType,
                     PubSubEventType,
                     BlockEventType,
-                    UnblockEventType
+                    UnblockEventType,
+                    RosterAddType,
+                    RosterRemoveType,
+                    RosterUpdateType
                 };
 
                 Event(std::shared_ptr<Message> stanza) : type(MessageType), stanza(stanza) {}
                 Event(std::shared_ptr<Presence> stanza) : type(PresenceType), stanza(stanza) {}
                 Event(const JID& from, std::shared_ptr<PubSubEventPayload> payload) : type(PubSubEventType), from(from), pubsubEvent(payload) {}
                 Event(const JID& item, Type type) : type(type), item(item) {}
                 Type type;
 
                 // Message & Presence
                 std::shared_ptr<Stanza> stanza;
 
                 // PubSubEvent
                 JID from;
                 std::shared_ptr<PubSubEventPayload> pubsubEvent;
 
-                // Blocklist
+                // Blocklist & Roster Push
                 JID item;
             };
 
             SluiftClient(
                     const JID& jid,
                     const std::string& password,
                     NetworkFactories* networkFactories,
                     SimpleEventLoop* eventLoop);
             ~SluiftClient();
@@ -75,19 +78,18 @@ namespace Swift {
             Client* getClient() {
                 return client;
             }
 
             ClientOptions& getOptions() {
                 return options;
             }
 
             void connect();
-            void connect(const std::string& host, int port);
             void waitConnected(int timeout);
             bool isConnected() const;
             void setTraceEnabled(bool b);
 
             template<typename T>
                 Sluift::Response sendPubSubRequest(
                     IQ::Type type, const JID& jid, std::shared_ptr<T> payload, int timeout) {
                 return sendRequest(client->getPubSubManager()->createRequest(
                             type, jid, payload), timeout);
@@ -104,31 +106,34 @@ namespace Swift {
             Sluift::Response sendVoidRequest(REQUEST_TYPE request, int timeout) {
                 boost::signals2::scoped_connection c(request->onResponse.connect(
                         boost::bind(&SluiftClient::handleRequestResponse, this, std::shared_ptr<Payload>(), _1)));
                 return doSendRequest(request, timeout);
             }
 
             void disconnect();
             void setSoftwareVersion(const std::string& name, const std::string& version, const std::string& os);
             boost::optional<SluiftClient::Event> getNextEvent(int timeout,
-                    boost::function<bool (const Event&)> condition = 0);
+                    boost::function<bool (const Event&)> condition = boost::function<bool (const Event&)>());
             std::vector<XMPPRosterItem> getRoster(int timeout);
             std::vector<JID> getBlockList(int timeout);
 
         private:
             Sluift::Response doSendRequest(std::shared_ptr<Request> request, int timeout);
 
             void handleIncomingMessage(std::shared_ptr<Message> stanza);
             void handleIncomingPresence(std::shared_ptr<Presence> stanza);
             void handleIncomingPubSubEvent(const JID& from, std::shared_ptr<PubSubEventPayload> event);
             void handleIncomingBlockEvent(const JID& item);
             void handleIncomingUnblockEvent(const JID& item);
             void handleInitialRosterPopulated();
+            void handleIncomingRosterAdd(const JID& item);
+            void handleIncomingRosterRemove(const JID& item);
+            void handleIncomingRosterUpdate(const JID& item);
             void handleRequestResponse(std::shared_ptr<Payload> response, std::shared_ptr<ErrorPayload> error);
             void handleDisconnected(const boost::optional<ClientError>& error);
 
         private:
             NetworkFactories* networkFactories;
             SimpleEventLoop* eventLoop;
             Client* client;
             ClientOptions options;
             ClientXMLTracer* tracer;