nim_qchat_system_notification_cpp_def.h

浏览该文件的文档.

 
#ifndef __NIM_QCHAT_SYSTEM_NOTIFICATION_CPP_DEF_H__
#define __NIM_QCHAT_SYSTEM_NOTIFICATION_CPP_DEF_H__
 
#include "nim_qchat_public_cpp_def.h"
 
#include "nim_qchat_cpp_wrapper/helper/nim_qchat_channel_cpp_def.h"
#include "nim_qchat_cpp_wrapper/helper/nim_qchat_message_cpp_def.h"
#include "nim_qchat_cpp_wrapper/helper/nim_qchat_server_cpp_def.h"
 
namespace nim {
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataBase {
    virtual ~QChatSystemNotificationDataBase(){};
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerInvite : QChatSystemNotificationDataBase {
    uint64_t request_id{0};
    QChatSystemNotificationDataServerInvite() = default;
    QChatSystemNotificationDataServerInvite(const NIMQChatSystemNotificationDataServerInvite& c_param) { request_id = c_param.request_id; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerInviteReject : QChatSystemNotificationDataBase {
    uint64_t request_id{0};
    QChatSystemNotificationDataServerInviteReject() = default;
    QChatSystemNotificationDataServerInviteReject(const NIMQChatSystemNotificationDataServerInviteReject& c_param) {
        request_id = c_param.request_id;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerApply : QChatSystemNotificationDataBase {
    uint64_t request_id{0};
    QChatSystemNotificationDataServerApply() = default;
    QChatSystemNotificationDataServerApply(const NIMQChatSystemNotificationDataServerApply& c_param) { request_id = c_param.request_id; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerApplyReject : QChatSystemNotificationDataBase {
    uint64_t request_id{0};
    QChatSystemNotificationDataServerApplyReject() = default;
    QChatSystemNotificationDataServerApplyReject(const NIMQChatSystemNotificationDataServerApplyReject& c_param) { request_id = c_param.request_id; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerCreate : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    QChatSystemNotificationDataServerCreate() = default;
    QChatSystemNotificationDataServerCreate(const NIMQChatSystemNotificationDataServerCreate& c_param) { server_info = c_param.server_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerUpdate : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    QChatSystemNotificationDataServerUpdate() = default;
    QChatSystemNotificationDataServerUpdate(const NIMQChatSystemNotificationDataServerUpdate& c_param) { server_info = c_param.server_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelCreate : QChatSystemNotificationDataBase {
    QChatChannelInfo channel_info;
    QChatSystemNotificationDataChannelCreate() = default;
    QChatSystemNotificationDataChannelCreate(const NIMQChatSystemNotificationDataChannelCreate& c_param) { channel_info = c_param.channel_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelUpdate : QChatSystemNotificationDataBase {
    QChatChannelInfo channel_info;
    QChatSystemNotificationDataChannelUpdate() = default;
    QChatSystemNotificationDataChannelUpdate(const NIMQChatSystemNotificationDataChannelUpdate& c_param) { channel_info = c_param.channel_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberInviteDone : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    std::vector<std::string> invite_accids;
    uint64_t request_id{0};
    QChatSystemNotificationDataMemberInviteDone() = default;
    QChatSystemNotificationDataMemberInviteDone(const NIMQChatSystemNotificationDataMemberInviteDone& c_param) {
        server_info = c_param.server_info;
        if (c_param.invite_accids) {
            nim::JsonArrayStringToList(c_param.invite_accids, invite_accids);
        }
        request_id = c_param.request_id;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberInviteAccept : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    std::string invite_accid;
    uint64_t request_id{0};
    QChatSystemNotificationDataMemberInviteAccept() = default;
    QChatSystemNotificationDataMemberInviteAccept(const NIMQChatSystemNotificationDataMemberInviteAccept& c_param) {
        server_info = c_param.server_info;
        invite_accid = c_param.invite_accid ? c_param.invite_accid : "";
        request_id = c_param.request_id;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberApplyDone : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    uint64_t request_id{0};
    QChatSystemNotificationDataMemberApplyDone() = default;
    QChatSystemNotificationDataMemberApplyDone(const NIMQChatSystemNotificationDataMemberApplyDone& c_param) {
        server_info = c_param.server_info;
        request_id = c_param.request_id;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberApplyAccept : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    std::string apply_accid;
    uint64_t request_id{0};
    QChatSystemNotificationDataMemberApplyAccept() = default;
    QChatSystemNotificationDataMemberApplyAccept(const NIMQChatSystemNotificationDataMemberApplyAccept& c_param) {
        server_info = c_param.server_info;
        apply_accid = c_param.apply_accid ? c_param.apply_accid : "";
        request_id = c_param.request_id;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberKick : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    std::vector<std::string> kick_accids;
    QChatSystemNotificationDataMemberKick() = default;
    QChatSystemNotificationDataMemberKick(const NIMQChatSystemNotificationDataMemberKick& c_param) {
        server_info = c_param.server_info;
        if (c_param.kick_accids)
            nim::JsonArrayStringToList(c_param.kick_accids, kick_accids);
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberLeave : QChatSystemNotificationDataBase {
    QChatServerInfo server_info;
    QChatSystemNotificationDataMemberLeave() = default;
    QChatSystemNotificationDataMemberLeave(const NIMQChatSystemNotificationDataMemberLeave& c_param) { server_info = c_param.server_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberUpdate : QChatSystemNotificationDataBase {
    QChatMemberInfo member_info;
    QChatSystemNotificationDataMemberUpdate() = default;
    QChatSystemNotificationDataMemberUpdate(const NIMQChatSystemNotificationDataMemberUpdate& c_param) { member_info = c_param.member_info; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataWhiteBlackRoleUpdate : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    uint64_t role_id{0};
    NIMQChatChannelWhiteBlackType type;
    NIMQChatChannelWhiteBlackOpeType ope_type;
    QChatSystemNotificationDataWhiteBlackRoleUpdate() = default;
    QChatSystemNotificationDataWhiteBlackRoleUpdate(const NIMQChatSystemNotificationDataWhiteBlackRoleUpdate& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        role_id = c_param.role_id;
        type = c_param.type;
        ope_type = c_param.ope_type;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataWhiteBlackMembersUpdate : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    std::vector<std::string> accids;
    NIMQChatChannelWhiteBlackType type;
    NIMQChatChannelWhiteBlackOpeType ope_type;
    QChatSystemNotificationDataWhiteBlackMembersUpdate() = default;
    QChatSystemNotificationDataWhiteBlackMembersUpdate(const NIMQChatSystemNotificationDataWhiteBlackMembersUpdate& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        for (size_t i = 0; i < c_param.accids_count; i++)
            accids.push_back(c_param.accids[i]);
        type = c_param.type;
        ope_type = c_param.ope_type;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataQuickCommentChanged : QChatSystemNotificationDataBase {
    uint64_t server_id = 0;
    uint64_t channel_id = 0;
    std::string msg_sender_accid;
    uint64_t msg_server_id{0};
    uint64_t msg_timestamp{0};
    uint64_t type{0};
    NIMQChatQuickCommentOperation operate_type;
    std::string operator_accid;
    QChatSystemNotificationDataQuickCommentChanged() = default;
    QChatSystemNotificationDataQuickCommentChanged(const NIMQChatSystemNotificationDataQuickCommentChanged& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        msg_sender_accid = c_param.msg_sender_accid;
        msg_server_id = c_param.msg_server_id;
        msg_timestamp = c_param.msg_timestamp;
        type = c_param.type;
        operate_type = c_param.operate_type;
        operator_accid = c_param.operator_accid;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelCategoryCreate : QChatSystemNotificationDataBase {
    QChatChannelCategoryInfo category_info;
    QChatSystemNotificationDataChannelCategoryCreate() = default;
    QChatSystemNotificationDataChannelCategoryCreate(const NIMQChatSystemNotificationDataChannelCategoryCreate& c_param) {
        category_info = c_param.category_info;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelCategoryRemove : QChatSystemNotificationDataBase {
    uint64_t category_id{0};
    QChatSystemNotificationDataChannelCategoryRemove() = default;
    QChatSystemNotificationDataChannelCategoryRemove(const NIMQChatSystemNotificationDataChannelCategoryRemove& c_param) {
        category_id = c_param.category_id;
    }
};
 
using QChatSystemNotificationDataChannelCategoryUpdate = QChatSystemNotificationDataChannelCategoryCreate;
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t category_id{0};
    uint64_t role_id{0};
    NIMQChatChannelWhiteBlackType type;
    NIMQChatChannelWhiteBlackOpeType ope_type;
    QChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate() = default;
    QChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate(const NIMQChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate& c_param) {
        server_id = c_param.server_id;
        category_id = c_param.category_id;
        role_id = c_param.role_id;
        type = c_param.type;
        ope_type = c_param.ope_type;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t category_id{0};
    std::vector<std::string> accids;
    NIMQChatChannelWhiteBlackType type;
    NIMQChatChannelWhiteBlackOpeType ope_type;
    QChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate() = default;
    QChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate(
        const NIMQChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate& c_param) {
        server_id = c_param.server_id;
        category_id = c_param.category_id;
        for (size_t i = 0; i < c_param.accids_count; i++)
            accids.push_back(c_param.accids[i]);
        type = c_param.type;
        ope_type = c_param.ope_type;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerRoleAddMember : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t role_id{0};
    std::vector<std::string> accids;
    QChatSystemNotificationDataServerRoleAddMember() = default;
    QChatSystemNotificationDataServerRoleAddMember(const NIMQChatSystemNotificationDataServerRoleAddMember& c_param) {
        server_id = c_param.server_id;
        role_id = c_param.role_id;
        for (size_t i = 0; i < c_param.accids_count; i++)
            accids.push_back(c_param.accids[i]);
    }
};
 
using QChatSystemNotificationDataServerRoleRemoveMember = QChatSystemNotificationDataServerRoleAddMember;
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerRolePermissionChange : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t role_id{0};
    QChatPermission permissions{};
    QChatSystemNotificationDataServerRolePermissionChange() = default;
    QChatSystemNotificationDataServerRolePermissionChange(const NIMQChatSystemNotificationDataServerRolePermissionChange& c_param) {
        server_id = c_param.server_id;
        role_id = c_param.role_id;
        for (size_t i = 0; i < c_param.permissions_count; i++) {
            auto permission = c_param.permissions[i].permission;
            auto option = c_param.permissions[i].option;
            permissions.emplace(permission, option);
        }
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelRolePermissionChange : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    uint64_t parent_role_id{0};
    uint64_t role_id{0};
    QChatPermission permissions{};
    QChatSystemNotificationDataChannelRolePermissionChange() = default;
    QChatSystemNotificationDataChannelRolePermissionChange(const NIMQChatSystemNotificationDataChannelRolePermissionChange& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        parent_role_id = c_param.parent_role_id;
        role_id = c_param.role_id;
        for (size_t i = 0; i < c_param.permissions_count; i++) {
            auto permission = c_param.permissions[i].permission;
            auto option = c_param.permissions[i].option;
            permissions.emplace(permission, option);
        }
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMemberRolePermissionChange : QChatSystemNotificationDataBase {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    std::string accid;
    QChatPermission permissions{};
    QChatSystemNotificationDataMemberRolePermissionChange() = default;
    QChatSystemNotificationDataMemberRolePermissionChange(const NIMQChatSystemNotificationDataMemberRolePermissionChange& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        accid = c_param.accid;
        for (size_t i = 0; i < c_param.permissions_count; i++) {
            auto permission = c_param.permissions[i].permission;
            auto option = c_param.permissions[i].option;
            permissions.emplace(permission, option);
        }
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelVisibilityChange : QChatSystemNotificationDataBase {
    bool visible{true};
    QChatSystemNotificationDataChannelVisibilityChange() = default;
    QChatSystemNotificationDataChannelVisibilityChange(const NIMQChatSystemNotificationDataChannelVisibilityChange& c_param) {
        visible = c_param.visible;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerEnterLeave : QChatSystemNotificationDataBase {
    bool is_enter{true};
    QChatSystemNotificationDataServerEnterLeave() = default;
    QChatSystemNotificationDataServerEnterLeave(const NIMQChatSystemNotificationDataServerEnterLeave& c_param) { is_enter = c_param.is_enter; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataServerJoinByInviteCode : QChatSystemNotificationDataBase {
    QChatServerInfo server_info{};
    uint64_t request_id{0};
    std::string invite_code;
    QChatSystemNotificationDataServerJoinByInviteCode() = default;
    QChatSystemNotificationDataServerJoinByInviteCode(const NIMQChatSystemNotificationDataServerJoinByInviteCode& c_param) {
        server_info = c_param.server_info;
        request_id = c_param.request_id;
        invite_code = c_param.invite_code ? c_param.invite_code : "";
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataChannelVisitorVisibilityChange : QChatSystemNotificationDataBase {
    bool visible{true};
    QChatSystemNotificationDataChannelVisitorVisibilityChange() = default;
    QChatSystemNotificationDataChannelVisitorVisibilityChange(const NIMQChatSystemNotificationDataChannelVisitorVisibilityChange& c_param) {
        visible = c_param.visible;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatUpdatedMyMemberInfo {
    uint64_t server_id;
    bool nick_changed{false};
    std::string nick;
    bool avatar_changed{false};
    std::string avatar;
    QChatUpdatedMyMemberInfo() = default;
    QChatUpdatedMyMemberInfo(const NIMQChatUpdatedMyMemberInfo& c_param) {
        server_id = c_param.server_id;
        if (c_param.nick) {
            nick_changed = true;
            nick = c_param.nick;
        }
        if (c_param.avatar) {
            avatar_changed = true;
            avatar = c_param.avatar;
        }
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationDataMyMemberInfoUpdated : QChatSystemNotificationDataBase {
    std::vector<QChatUpdatedMyMemberInfo> updated_infos;
    QChatSystemNotificationDataMyMemberInfoUpdated() = default;
    QChatSystemNotificationDataMyMemberInfoUpdated(const NIMQChatSystemNotificationDataMyMemberInfoUpdated& c_param) {
        for (size_t i = 0; i < c_param.updated_infos_count; i++) {
            updated_infos.emplace_back(c_param.updated_infos[i]);
        }
    }
};
 
template <typename CPP_TYPE, typename C_TYPE>
static std::shared_ptr<QChatSystemNotificationDataBase> MsgDataCPPToC(void* c_msg_data) {
    return std::make_shared<CPP_TYPE>(*(C_TYPE*)c_msg_data);
};
// clang-format off
static std::map<NIMQChatSystemNotificationType, std::function<std::shared_ptr<QChatSystemNotificationDataBase>(void*)>> msg_data_transform_map_{
    {kNIMQChatSystemNotificationTypeMemberInvite, MsgDataCPPToC<QChatSystemNotificationDataServerInvite, NIMQChatSystemNotificationDataServerInvite>},
    {kNIMQChatSystemNotificationTypeMemberInviteReject, MsgDataCPPToC<QChatSystemNotificationDataServerInviteReject, NIMQChatSystemNotificationDataServerInviteReject>},
    {kNIMQChatSystemNotificationTypeMemberApply, MsgDataCPPToC<QChatSystemNotificationDataServerApply, NIMQChatSystemNotificationDataServerApply>},
    {kNIMQChatSystemNotificationTypeMemberApplyReject, MsgDataCPPToC<QChatSystemNotificationDataServerApplyReject, NIMQChatSystemNotificationDataServerApplyReject>},
    {kNIMQChatSystemNotificationTypeServerCreate, MsgDataCPPToC<QChatSystemNotificationDataServerCreate, NIMQChatSystemNotificationDataServerCreate>},
    {kNIMQChatSystemNotificationTypeServerUpdate, MsgDataCPPToC<QChatSystemNotificationDataServerUpdate, NIMQChatSystemNotificationDataServerUpdate>},
    {kNIMQChatSystemNotificationTypeChannelCreate, MsgDataCPPToC<QChatSystemNotificationDataChannelCreate, NIMQChatSystemNotificationDataChannelCreate>},
    {kNIMQChatSystemNotificationTypeChannelUpdate, MsgDataCPPToC<QChatSystemNotificationDataChannelUpdate, NIMQChatSystemNotificationDataChannelUpdate>},
    {kNIMQChatSystemNotificationTypeMemberInviteDone, MsgDataCPPToC<QChatSystemNotificationDataMemberInviteDone, NIMQChatSystemNotificationDataMemberInviteDone>},
    {kNIMQChatSystemNotificationTypeMemberInviteAccept, MsgDataCPPToC<QChatSystemNotificationDataMemberInviteAccept, NIMQChatSystemNotificationDataMemberInviteAccept>},
    {kNIMQChatSystemNotificationTypeMemberApplyDone, MsgDataCPPToC<QChatSystemNotificationDataMemberApplyDone, NIMQChatSystemNotificationDataMemberApplyDone>},
    {kNIMQChatSystemNotificationTypeMemberApplyAccept, MsgDataCPPToC<QChatSystemNotificationDataMemberApplyAccept, NIMQChatSystemNotificationDataMemberApplyAccept>},
    {kNIMQChatSystemNotificationTypeMemberKick, MsgDataCPPToC<QChatSystemNotificationDataMemberKick, NIMQChatSystemNotificationDataMemberKick>},
    {kNIMQChatSystemNotificationTypeMemberLeave, MsgDataCPPToC<QChatSystemNotificationDataMemberLeave, NIMQChatSystemNotificationDataMemberLeave>},
    {kNIMQChatSystemNotificationTypeMemberUpdate, MsgDataCPPToC<QChatSystemNotificationDataMemberUpdate, NIMQChatSystemNotificationDataMemberUpdate>},
    {kNIMQChatSystemNotificationTypeWhiteBlackRoleUpdate, MsgDataCPPToC<QChatSystemNotificationDataWhiteBlackRoleUpdate, NIMQChatSystemNotificationDataWhiteBlackRoleUpdate>},
    {kNIMQChatSystemNotificationTypeWhiteBlackMembersUpdate, MsgDataCPPToC<QChatSystemNotificationDataWhiteBlackMembersUpdate, NIMQChatSystemNotificationDataWhiteBlackMembersUpdate>},
    {kNIMQChatSystemNotificationTypeQuickCommentChanged, MsgDataCPPToC<QChatSystemNotificationDataQuickCommentChanged, NIMQChatSystemNotificationDataQuickCommentChanged>},
    {kNIMQChatSystemNotificationTypeChannelCategoryCreate, MsgDataCPPToC<QChatSystemNotificationDataChannelCategoryCreate, NIMQChatSystemNotificationDataChannelCategoryCreate>},
    {kNIMQChatSystemNotificationTypeChannelCategoryRemove, MsgDataCPPToC<QChatSystemNotificationDataChannelCategoryRemove, NIMQChatSystemNotificationDataChannelCategoryRemove>},
    {kNIMQChatSystemNotificationTypeChannelCategoryUpdate, MsgDataCPPToC<QChatSystemNotificationDataChannelCategoryUpdate, NIMQChatSystemNotificationDataChannelCategoryUpdate>},
    {kNIMQChatSystemNotificationTypeChannelCategoryWhiteBlackRoleUpdate, MsgDataCPPToC<QChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate, NIMQChatSystemNotificationDataChannelCategoryWhiteBlackRoleUpdate>},
    {kNIMQChatSystemNotificationTypeChannelCategoryWhiteBlackMembersUpdate, MsgDataCPPToC<QChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate, NIMQChatSystemNotificationDataChannelCategoryWhiteBlackMembersUpdate>},
    {kNIMQChatSystemNotificationTypeServerRoleAddMember, MsgDataCPPToC<QChatSystemNotificationDataServerRoleAddMember, NIMQChatSystemNotificationDataServerRoleAddMember>},
    {kNIMQChatSystemNotificationTypeServerRoleRemoveMember, MsgDataCPPToC<QChatSystemNotificationDataServerRoleRemoveMember, NIMQChatSystemNotificationDataServerRoleRemoveMember>},
    {kNIMQChatSystemNotificationTypeServerRolePermissionChange, MsgDataCPPToC<QChatSystemNotificationDataServerRolePermissionChange, NIMQChatSystemNotificationDataServerRolePermissionChange>},
    {kNIMQChatSystemNotificationTypeChannelRolePermissionChange, MsgDataCPPToC<QChatSystemNotificationDataChannelRolePermissionChange, NIMQChatSystemNotificationDataChannelRolePermissionChange>},
    {kNIMQChatSystemNotificationTypeMemberRolePermissionChange, MsgDataCPPToC<QChatSystemNotificationDataMemberRolePermissionChange, NIMQChatSystemNotificationDataMemberRolePermissionChange>},
    {kNIMQChatSystemNotificationTypeChannelVisibilityChange, MsgDataCPPToC<QChatSystemNotificationDataChannelVisibilityChange, NIMQChatSystemNotificationDataChannelVisibilityChange>},
    {kNIMQChatSystemNotificationTypeServerEnterLeave, MsgDataCPPToC<QChatSystemNotificationDataServerEnterLeave, NIMQChatSystemNotificationDataServerEnterLeave>},
    {kNIMQChatSystemNotificationTypeServerJoinByInviteCode, MsgDataCPPToC<QChatSystemNotificationDataServerJoinByInviteCode, NIMQChatSystemNotificationDataServerJoinByInviteCode>},
    {kNIMQChatSystemNotificationTypeChannelVisitorVisibilityChange, MsgDataCPPToC<QChatSystemNotificationDataChannelVisitorVisibilityChange, NIMQChatSystemNotificationDataChannelVisitorVisibilityChange>},
    {kNIMQChatSystemNotificationTypeMyMemberInfoUpdated, MsgDataCPPToC<QChatSystemNotificationDataMyMemberInfoUpdated, NIMQChatSystemNotificationDataMyMemberInfoUpdated>},
};
// clang-format on
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotification {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    std::string msg_id{""};
    NIMQChatSystemNotificationType msg_type{kNIMQChatSystemNotificationTypeUnkonwn};
    std::string msg_body{""};
    std::string msg_attach{""};
    std::string msg_ext{""};
    bool resend_flag{false};
    std::vector<std::string> to_accids{};
    bool history_enable{false};
    std::string push_payload{""};
    std::string push_content{""};
    bool push_enable{false};
    bool need_badge{true};
    bool need_push_nick{true};
    bool route_enable{true};
    std::string env{""};
    // 以下字段仅在收到消息时有效
    NIMQChatSystemNotificationToType to_type{kNIMQChatSystemNotificationToTypeUnknown};
    NIMQChatSystemNotificationStatus status{kNIMQChatSystemNotificationNormal};
    uint64_t msg_server_id{0};
    std::string from_accid{""};
    uint32_t from_client_type{0};
    std::string from_device_id{""};
    std::string from_nick{""};
    uint64_t timestamp{0};
    uint64_t update_timestamp{0};
    std::shared_ptr<QChatSystemNotificationDataBase> msg_data{nullptr};
    std::string callback_ext{""};
    QChatSystemNotification() = default;
    QChatSystemNotification(const NIMQChatSystemNotification& c_param) {
        to_type = c_param.to_type;
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        msg_id = c_param.msg_id ? c_param.msg_id : "";
        msg_type = c_param.msg_type;
        msg_body = c_param.msg_body ? c_param.msg_body : "";
        msg_attach = c_param.msg_attach ? c_param.msg_attach : "";
        msg_ext = c_param.msg_ext ? c_param.msg_ext : "";
        resend_flag = c_param.resend_flag;
        if (c_param.to_accids)
            nim::JsonArrayStringToList(c_param.to_accids, to_accids);
        route_enable = c_param.route_enable;
        env = c_param.env ? c_param.env : "";
        // fill by server
        status = c_param.status;
        history_enable = c_param.history_enable;
        push_payload = c_param.push_payload ? c_param.push_payload : "";
        push_content = c_param.push_content ? c_param.push_content : "";
        push_enable = c_param.push_enable;
        need_badge = c_param.need_badge;
        need_push_nick = c_param.need_push_nick;
        msg_server_id = c_param.msg_server_id;
        from_accid = c_param.from_accid ? c_param.from_accid : "";
        from_client_type = c_param.from_client_type;
        from_device_id = c_param.from_device_id ? c_param.from_device_id : "";
        from_nick = c_param.from_nick ? c_param.from_nick : "";
        timestamp = c_param.timestamp;
        update_timestamp = c_param.update_timestamp;
        if (c_param.msg_data) {
            auto iter = msg_data_transform_map_.find(msg_type);
            if (iter != msg_data_transform_map_.end()) {
                msg_data = iter->second(c_param.msg_data);
            }
        }
        callback_ext = c_param.callback_ext ? c_param.callback_ext : "";
    }
    NIMQChatSystemNotification ToCParam() const {
        nim::StrListToJsonString(to_accids, to_accids_json_array);
        NIMQChatSystemNotification c_param = {};
        c_param.to_type = to_type;
        c_param.server_id = server_id;
        c_param.channel_id = channel_id;
        c_param.msg_id = const_cast<char*>(msg_id.c_str());
        c_param.msg_type = msg_type;
        c_param.msg_body = const_cast<char*>(msg_body.c_str());
        c_param.msg_attach = const_cast<char*>(msg_attach.c_str());
        c_param.msg_ext = const_cast<char*>(msg_ext.c_str());
        c_param.resend_flag = resend_flag;
        c_param.to_accids = const_cast<char*>(to_accids_json_array.c_str());
        c_param.history_enable = history_enable;
        c_param.push_payload = const_cast<char*>(push_payload.c_str());
        c_param.push_content = const_cast<char*>(push_content.c_str());
        c_param.push_enable = push_enable;
        c_param.need_badge = need_badge;
        c_param.need_push_nick = need_push_nick;
        c_param.route_enable = route_enable;
        c_param.env = const_cast<char*>(env.c_str());
        // fill by server
        c_param.status = status;
        c_param.msg_server_id = msg_server_id;
        c_param.from_accid = const_cast<char*>(from_accid.c_str());
        c_param.from_client_type = from_client_type;
        c_param.from_device_id = const_cast<char*>(from_device_id.c_str());
        c_param.from_nick = const_cast<char*>(from_nick.c_str());
        c_param.timestamp = timestamp;
        c_param.update_timestamp = update_timestamp;
        c_param.callback_ext = const_cast<char*>(callback_ext.c_str());
        return c_param;
    }
    void AdaptToType() {
        if (!to_accids.empty()) {
            if (channel_id != 0) {
                to_type = kNIMQChatSystemNotificationToTypeChannelAccids;
            } else if (server_id != 0) {
                to_type = kNIMQChatSystemNotificationToTypeServerAccids;
            } else {
                to_type = kNIMQChatSystemNotificationToTypeAccids;
            }
        } else {
            if (channel_id != 0) {
                to_type = kNIMQChatSystemNotificationToTypeChannel;
            } else if (server_id != 0) {
                to_type = kNIMQChatSystemNotificationToTypeServer;
            }
        }
    }
 
protected:
    // 以下字段为内部使用
    mutable std::string to_accids_json_array;
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatTypingEvent {
    uint64_t server_id{0};
    uint64_t channel_id{0};
    std::string extension{""};
    // 以下字段仅在收到事件时有效
    std::string from_accid{""};
    std::string from_nick{""};
    uint64_t timestamp{0};
    QChatTypingEvent() = default;
    QChatTypingEvent(const NIMQChatTypingEvent& c_param) {
        server_id = c_param.server_id;
        channel_id = c_param.channel_id;
        extension = c_param.extension ? c_param.extension : "";
        from_accid = c_param.from_accid ? c_param.from_accid : "";
        from_nick = c_param.from_nick ? c_param.from_nick : "";
        timestamp = c_param.timestamp;
    }
    NIMQChatTypingEvent ToCParam() const {
        NIMQChatTypingEvent c_param = {};
        c_param.server_id = server_id;
        c_param.channel_id = channel_id;
        c_param.extension = const_cast<char*>(extension.c_str());
        c_param.from_accid = const_cast<char*>(from_accid.c_str());
        c_param.from_nick = const_cast<char*>(from_nick.c_str());
        c_param.timestamp = timestamp;
        return c_param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRecvSystemNotificationResp {
    QChatSystemNotification notification{};
    bool is_leave{false};
    QChatRecvSystemNotificationResp() = default;
    QChatRecvSystemNotificationResp(const NIMQChatRecvSystemNotificationResp& c_resp) {
        notification = c_resp.notification;
        is_leave = c_resp.is_leave;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSystemNotificationUpdatedResp {
    uint32_t res_code{0};
    QChatMessageUpdateInfo update_info{};
    QChatSystemNotification notification{};
    QChatSystemNotificationUpdatedResp() = default;
    QChatSystemNotificationUpdatedResp(const NIMQChatSystemNotificationUpdatedResp& c_resp) {
        update_info = c_resp.update_info;
        notification = c_resp.notification;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSendSystemNotificationResp {
    uint32_t res_code{0};
    QChatSystemNotification notification{};
    QChatSendSystemNotificationResp() = default;
    QChatSendSystemNotificationResp(const NIMQChatSendSystemNotificationResp& c_resp) {
        res_code = c_resp.res_code;
        if (c_resp.res_code != kNIMResSuccess)
            return;
        notification = c_resp.notification;
    }
    NIMQChatSendSystemNotificationResp ToCParam() const {
        NIMQChatSendSystemNotificationResp c_resp = {};
        c_resp.res_code = res_code;
        c_resp.notification = notification.ToCParam();
        return c_resp;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatUpdateSystemNotificationResp {
    uint32_t res_code{0};
    QChatSystemNotification notification{};
    QChatUpdateSystemNotificationResp() = default;
    QChatUpdateSystemNotificationResp(const NIMQChatUpdateSystemNotificationResp& c_resp) {
        res_code = c_resp.res_code;
        if (c_resp.res_code != kNIMResSuccess)
            return;
        notification = c_resp.notification;
    }
    NIMQChatUpdateSystemNotificationResp ToCParam() const {
        NIMQChatUpdateSystemNotificationResp c_resp = {};
        c_resp.res_code = res_code;
        c_resp.notification = notification.ToCParam();
        return c_resp;
    }
};
 
using QChatMarkReadSystemNotificationResp = QChatBaseResp;
 
using QChatMarkSystemNotificationsReadResp = QChatBaseResp;
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRecvTypingEventResp {
    QChatTypingEvent typing_event{};
    QChatRecvTypingEventResp() = default;
    QChatRecvTypingEventResp(const NIMQChatRecvTypingEventResp& c_resp) { typing_event = c_resp.typing_event; }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSendTypingEventResp {
    uint32_t res_code{0};
    QChatTypingEvent typing_event{};
    QChatSendTypingEventResp() = default;
    QChatSendTypingEventResp(const NIMQChatSendTypingEventResp& c_resp) {
        res_code = c_resp.res_code;
        if (c_resp.res_code != kNIMResSuccess)
            return;
        typing_event = c_resp.typing_event;
    }
    NIMQChatSendTypingEventResp ToCParam() const {
        NIMQChatSendTypingEventResp c_resp = {};
        c_resp.res_code = res_code;
        c_resp.typing_event = typing_event.ToCParam();
        return c_resp;
    }
};
 
typedef std::function<void(const QChatRecvSystemNotificationResp&)> RecvSystemNotificationCallback;
typedef std::function<void(const QChatSendSystemNotificationResp&)> SendSystemNotificationCallback;
typedef std::function<void(const QChatSystemNotificationUpdatedResp&)> SystemNotificationUpdatedCallback;
typedef std::function<void(const QChatUpdateSystemNotificationResp&)> UpdateSystemNotificationCallback;
typedef std::function<void(const QChatMarkSystemNotificationsReadResp&)> MarkReadSystemNotificationCallback;
typedef std::function<void(const QChatRecvTypingEventResp&)> RecvTypingEventCallback;
typedef std::function<void(const QChatSendTypingEventResp&)> SendTypingEventCallback;
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegRecvSystemNotificationCbParam {
    RecvSystemNotificationCallback cb{nullptr};
    NIMQChatRegRecvSystemNotificationCbParam ToCParam() const {
        static RecvSystemNotificationCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegRecvSystemNotificationCbParam param = {};
        param.cb = [](const NIMQChatRecvSystemNotificationResp* resp) {
            if (cb_holder)
                cb_holder(*resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegSystemNotificationUpdatedCbParam {
    SystemNotificationUpdatedCallback cb{nullptr};
    NIMQChatRegSystemNotificationUpdatedCbParam ToCParam() const {
        static SystemNotificationUpdatedCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegSystemNotificationUpdatedCbParam param = {};
        param.cb = [](const NIMQChatSystemNotificationUpdatedResp* resp) {
            if (cb_holder)
                cb_holder(*resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSendSystemNotificationParam {
    SendSystemNotificationCallback cb{nullptr};
    QChatSystemNotification notification{};
    QChatSendSystemNotificationParam() = default;
    QChatSendSystemNotificationParam(const NIMQChatSendSystemNotificationParam& c_param) {
        notification = c_param.notification;
        cb = [c_param](const QChatSendSystemNotificationResp& response) {
            auto c_response = response.ToCParam();
            c_response.user_data = c_param.user_data;
            c_param.cb(&c_response);
        };
    }
    NIMQChatSendSystemNotificationParam ToCParam() const {
        auto cb_holder = new SendSystemNotificationCallback(cb);
        NIMQChatSendSystemNotificationParam param = {};
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatSendSystemNotificationResp* resp) {
            InvokeCallback<SendSystemNotificationCallback, NIMQChatSendSystemNotificationResp>(resp);
        };
        param.notification = notification.ToCParam();
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatUpdateSystemNotificationParam {
    UpdateSystemNotificationCallback cb{nullptr};
    uint64_t msg_server_id{0};
    NIMQChatSystemNotificationType msg_type{kNIMQChatSystemNotificationTypeUnkonwn};
    NIMQChatSystemNotificationStatus status{kNIMQChatSystemNotificationNormal};
    std::string msg_body;
    std::string msg_ext;
    QChatMessageUpdateInfo update_info;
    QChatUpdateSystemNotificationParam() = default;
    QChatUpdateSystemNotificationParam(const NIMQChatUpdateSystemNotificationParam& c_param) {
        msg_server_id = c_param.msg_server_id;
        msg_type = c_param.msg_type;
        status = c_param.status;
        msg_body = c_param.msg_body;
        msg_ext = c_param.msg_ext;
        update_info = c_param.update_info;
        cb = [c_param](const QChatUpdateSystemNotificationResp& response) {
            auto c_response = response.ToCParam();
            c_response.user_data = c_param.user_data;
            c_param.cb(&c_response);
        };
    }
    NIMQChatUpdateSystemNotificationParam ToCParam() const {
        auto cb_holder = new UpdateSystemNotificationCallback(cb);
        NIMQChatUpdateSystemNotificationParam param = {};
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatUpdateSystemNotificationResp* resp) {
            InvokeCallback<UpdateSystemNotificationCallback, NIMQChatUpdateSystemNotificationResp>(resp);
        };
        param.msg_server_id = msg_server_id;
        param.msg_type = msg_type;
        param.status = status;
        param.msg_body = const_cast<char*>(msg_body.c_str());
        param.msg_ext = const_cast<char*>(msg_ext.c_str());
        param.update_info = update_info.ToCParam();
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatMarkSystemNotificationsReadParam {
    MarkReadSystemNotificationCallback cb{nullptr};
    std::vector<NIMQChatSystemNotificationMarkReadInfo> mark_read_infos{};
    QChatMarkSystemNotificationsReadParam() = default;
    QChatMarkSystemNotificationsReadParam(const NIMQChatMarkSystemNotificationsReadParam& c_param) {
        for (size_t i = 0; i < c_param.mark_read_infos_count; i++) {
            mark_read_infos.push_back(c_param.mark_read_infos[i]);
        }
        cb = [c_param](const QChatMarkSystemNotificationsReadResp& response) {
            auto c_response = response.ToCParam();
            c_response.user_data = c_param.user_data;
            c_param.cb(&c_response);
        };
    }
    NIMQChatMarkSystemNotificationsReadParam ToCParam() const {
        auto cb_holder = new MarkReadSystemNotificationCallback(cb);
        NIMQChatMarkSystemNotificationsReadParam param = {};
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatMarkReadSystemNotificationResp* resp) {
            InvokeCallback<MarkReadSystemNotificationCallback, NIMQChatMarkReadSystemNotificationResp>(resp);
        };
        param.mark_read_infos_count = mark_read_infos.size();
        param.mark_read_infos = const_cast<NIMQChatSystemNotificationMarkReadInfo*>(mark_read_infos.data());
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatRegRecvTypingEventCbParam {
    RecvTypingEventCallback cb{nullptr};
    NIMQChatRegRecvTypingEventCbParam ToCParam() const {
        static RecvTypingEventCallback cb_holder = nullptr;
        cb_holder = cb;
        NIMQChatRegRecvTypingEventCbParam param = {};
        param.cb = [](const NIMQChatRecvTypingEventResp* resp) {
            if (cb_holder)
                cb_holder(*resp);
        };
        return param;
    }
};
 
struct NIM_QCHAT_SDK_CPPWRAPPER_DLL_API QChatSendTypingEventParam {
    SendTypingEventCallback cb{nullptr};
    QChatTypingEvent typing_event{};
    QChatSendTypingEventParam() = default;
    QChatSendTypingEventParam(const NIMQChatSendTypingEventParam& c_param) {
        typing_event = c_param.typing_event;
        cb = [c_callback = c_param.cb, user_data = c_param.user_data](const QChatSendTypingEventResp& resp) {
            NIMQChatSendTypingEventResp c_response = resp.ToCParam();
            c_response.user_data = user_data;
            c_callback(&c_response);
        };
    }
    NIMQChatSendTypingEventParam ToCParam() const {
        auto cb_holder = new SendTypingEventCallback(cb);
        NIMQChatSendTypingEventParam param = {};
        param.user_data = cb_holder;
        param.cb = [](const NIMQChatSendTypingEventResp* resp) {
            InvokeCallback<SendTypingEventCallback, NIMQChatSendTypingEventResp>(resp);
        };
        param.typing_event = typing_event.ToCParam();
        return param;
    }
};
 
}  // namespace nim
 
#endif  // __NIM_QCHAT_SYSTEM_NOTIFICATION_CPP_DEF_H__