member_data.h

Go to the documentation of this file.

#pragma once
#include <deque>
#include <string>
#include <unordered_map>
#include <chrono>
#include <optional>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <spdlog/common.h>
#include <spdlog/logger.h>
#include "webcface/common/encoding.h"
#include "webcface/common/internal/map.h"
#include "webcface/common/internal/message/pack.h"
#include "webcface/common/internal/message/canvas2d.h"
#include "webcface/common/internal/message/canvas3d.h"
#include "webcface/common/internal/message/func.h"
#include "webcface/common/internal/message/image.h"
#include "webcface/common/internal/message/log.h"
#include "webcface/common/internal/message/robot_model.h"
#include "webcface/common/internal/message/sync.h"
#include "webcface/common/internal/message/view.h"
#include "webcface/server/server.h"
 
WEBCFACE_NS_BEGIN
namespace server {
 
std::pair<unsigned int, SharedString> findReqField(internal::StrMap2<unsigned int> &req,
                                                   const SharedString &member,
                                                   const SharedString &field);
 
struct MemberData {
    spdlog::sink_ptr sink;
    std::shared_ptr<spdlog::logger> logger;
    spdlog::level::level_enum logger_level;
 
    ServerStorage *store;
 
    wsConnPtr con;
    std::string remote_addr;
    bool connected() const { return con != nullptr; }
 
    bool sync_init = false;
 
    SharedString name;
    unsigned int member_id;
    message::SyncInit init_data;
    internal::StrMap1<std::shared_ptr<std::vector<double>>> value;
    internal::StrMap1<std::shared_ptr<ValAdaptor>> text;
    internal::StrMap1<std::shared_ptr<message::FuncInfo>> func;
    internal::StrMap1<message::ViewData> view;
    internal::StrMap1<message::Canvas3DData> canvas3d;
    internal::StrMap1<message::Canvas2DData> canvas2d;
 
    internal::StrMap1<message::ImageFrame> image;
    std::condition_variable image_cv;
    std::mutex image_m;
    internal::StrMap1<int> image_changed;
    internal::StrMap2<int> image_req_changed;
    internal::StrMap2<message::ImageReq> image_req_info;
 
    std::chrono::system_clock::time_point last_sync_time;
    internal::StrMap2<unsigned int> value_req, text_req, view_req, image_req,
        view_old_req, robot_model_req, canvas3d_req, canvas3d_old_req,
        canvas2d_req, canvas2d_old_req, log_req;
 
    // image_convert_thread[imageのmember][imageのfield] =
    // imageを変換してthisに送るスレッド
    internal::StrMap2<std::optional<std::thread>> image_convert_thread;
    void imageConvertThreadMain(const SharedString &member,
                                const SharedString &field);
    internal::StrMap1<std::vector<std::shared_ptr<message::RobotLink>>> robot_model;
 
    bool hasReq(const SharedString &member);
    internal::StrSet1 log_req_default;
    internal::StrMap1<std::shared_ptr<std::deque<message::LogLine>>> log;
    std::unordered_map<unsigned int, std::unordered_map<std::size_t, int>>
        pending_calls;
 
    inline static unsigned int last_member_id = 0;
 
    MemberData() = delete;
    MemberData(const MemberData &) = delete;
    MemberData &operator=(const MemberData &) = delete;
    explicit MemberData(ServerStorage *store, const wsConnPtr &con,
                        std::string_view remote_addr,
                        const spdlog::sink_ptr &sink,
                        spdlog::level::level_enum level);
    ~MemberData() { onClose(); }
 
    void onConnect();
    void onRecv(const std::string &msg);
    void onClose();
    std::atomic<bool> closing = false;
 
    void sendPing();
    static constexpr std::chrono::milliseconds ping_interval{5000};
    std::chrono::system_clock::time_point last_send_ping;
    std::optional<std::chrono::milliseconds> last_ping_duration;
    bool ping_status_req = false;
 
    std::stringstream send_buffer;
    int send_len = 0;
    void send();
    void send(const std::string &msg);
    template <typename T>
    void send(const T &obj) {
        logger->debug("-> sending {}", obj);
        send(message::packSingle(obj));
    }
 
    template <typename T>
    void pack(const T &obj) {
        logger->debug("-> sending {}", obj);
        message::pack(send_buffer, send_len, obj);
    }
};
} // namespace server
WEBCFACE_NS_END