nim_subscribe_event_helper.h

Go to the documentation of this file.

 
#ifndef _NIM_SDK_CPP_SUBSCRIBE_EVENT_HELPER_H_
#define _NIM_SDK_CPP_SUBSCRIBE_EVENT_HELPER_H_
 
#include <functional>
#include <list>
#include <set>
#include <string>
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_define_include.h"
#include "nim_wrapper_util/nim_json_util.h"
namespace nim {
 
struct NIM_SDK_CPPWRAPPER_DLL_API EventData {
    int event_type_;
    int event_value_;
    std::string client_msg_id_;
    std::string config_;
    int64_t ttl_;
    NIMEventBroadcastType broadcast_type_;
    NIMEventSyncType sync_self_;
 
public:
    int readonly_ttl_type;
    int readonly_durable_;
    int64_t readonly_event_time_;
    std::string readonly_server_msg_id_;
    int readonly_client_type_;
    std::string readonly_nim_config_;
    std::string readonly_multi_config_;
 
public:
    std::string readonly_publisher_accid_;
    std::string readonly_consid_;
 
    EventData()
        : event_type_(0)
        , event_value_(0)
        , ttl_(0)
        , broadcast_type_(kNIMEventBroadcastTypeOnline)
        , sync_self_(kNIMEventSyncTypeNoSelf)
        , readonly_ttl_type(0)
        , readonly_durable_(0)
        , readonly_event_time_(0)
        , readonly_client_type_(0) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMEventEventType] = event_type_;
        values[kNIMEventEventValue] = event_value_;
        values[kNIMEventMsgIdClient] = client_msg_id_;
        values[kNIMEventConfig] = config_;
        values[kNIMEventTTL] = ttl_;
        values[kNIMEventBroadcastType] = broadcast_type_;
        values[kNIMEventSyncSelf] = sync_self_;
 
        return GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API EventOnlineClientType {
    std::set<NIMClientType> online_client_type_;
 
    bool ParseConfig(const std::string& multi_config_json) {
        nim_cpp_wrapper_util::Json::Value values;
        if (nim::ParseJsonValue(multi_config_json, values) && values.isObject()) {
            if (values.isMember(kNIMEventNimConfigOnlineClient)) {
                nim_cpp_wrapper_util::Json::Value online_values = values[kNIMEventNimConfigOnlineClient];
                if (online_values.isArray()) {
                    for (int i = 0; i < (int)online_values.size(); ++i) {
                        NIMClientType client_type = (NIMClientType)online_values[i].asUInt();
                        online_client_type_.insert(client_type);
                    }
 
                    return true;
                }
            }
        }
 
        return false;
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API EventSubscribeData {
    int event_type_;
    int64_t ttl_;
    NIMEventSubscribeSyncEventType sync_event_;
 
    std::string publisher_accid_;
    std::string subscribe_accid_;
    int64_t subscribe_time_;
    EventSubscribeData()
        : event_type_(0)
        , ttl_(0)
        , sync_event_(kNIMEventSubscribeSyncTypeUnSync)
        , subscribe_time_(0) {}
};
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseEventData(const std::string& event_json, EventData& event_data);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseEventData(const nim_cpp_wrapper_util::Json::Value& values, EventData& event_data);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseEventDataList(const std::string& event_list_json, std::list<EventData>& event_data_list);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseEventSubscribeData(const nim_cpp_wrapper_util::Json::Value& values, EventSubscribeData& event_subscribe);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseEventSubscribeDataList(const std::string& subscribe_list_json,
    std::list<EventSubscribeData>& event_subscribe_list);
 
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_SUBSCRIBE_EVENT_HELPER_H_