data_store2.h

Go to the documentation of this file.

#pragma once
#include <deque>
#include <mutex>
#include <optional>
#include "webcface/common/internal/map.h"
#include "webcface/field.h"
#include "webcface/log.h"
#include "webcface/common/val_adaptor.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
template <typename T, typename ReqT = int>
class SyncDataStore2 {
    StrMap1<T> data_send;
    StrMap1<T> data_send_prev;
    StrMap2<T> data_recv;
    StrSet2 entry;
    StrMap2<unsigned int> req;
    StrMap2<ReqT> req_info;
 
    SharedString self_member_name;
 
 
  public:
    explicit SyncDataStore2(const SharedString &name);
 
    std::recursive_mutex mtx;
 
    bool isSelf(const SharedString &member) const;
 
    unsigned int addReq(const SharedString &member, const SharedString &field);
    unsigned int addReq(const SharedString &member, const SharedString &field,
                        const ReqT &req_info);
 
    void setSend(const SharedString &name, const T &data);
    void setSend(const FieldBase &base, const T &data);
 
    void setRecv(const SharedString &from, const SharedString &name,
                 const T &data);
    void setRecv(const FieldBase &base, const T &data);
    void clearRecv(const SharedString &from, const SharedString &name);
    void clearRecv(const FieldBase &base);
 
    std::optional<T> getRecv(const SharedString &from,
                             const SharedString &name);
    std::optional<T> getRecv(const FieldBase &base);
    bool unsetRecv(const SharedString &from, const SharedString &name);
    bool unsetRecv(const FieldBase &base);
 
    void initMember(const SharedString &from);
    void setEntry(const SharedString &from, const SharedString &e);
 
    StrSet1 getEntry(const SharedString &from);
    StrSet1 getEntry(const FieldBase &base);
 
    std::pair<SharedString, SharedString> getReq(unsigned int req_id,
                                                 const SharedString &sub_field);
    const ReqT &getReqInfo(const SharedString &member,
                           const SharedString &field);
 
    StrMap1<T> transferSend(bool is_first);
    StrMap1<T> getSendPrev(bool is_first);
 
    StrMap2<unsigned int> transferReq();
};
 
struct FuncInfo;
struct RobotLinkData;
} // namespace internal
class ImageFrame;
namespace message {
struct ViewData;
struct Canvas2DData;
struct Canvas3DData;
struct ImageReq;
} // namespace message
namespace internal {
using ValueData = std::vector<double>;
using TextData = ValAdaptor;
using FuncData = FuncInfo;
using RobotModelData = std::vector<std::shared_ptr<internal::RobotLinkData>>;
using ImageData = ImageFrame;
 
struct LogData {
    std::deque<LogLineData> data;
    std::size_t sent_lines = 0;
 
    LogData() = default;
    explicit LogData(const std::deque<LogLineData> &data) : data(data) {}
 
    std::vector<LogLineData> getDiff() {
        auto begin = data.cbegin() + static_cast<int>(sent_lines);
        auto end = data.cend();
        sent_lines = data.size();
        return std::vector<LogLineData>(begin, end);
    }
    std::vector<LogLineData> getAll() {
        sent_lines = data.size();
        return std::vector<LogLineData>(data.cbegin(), data.cend());
    }
};
 
#if WEBCFACE_SYSTEM_DLLEXPORT
extern template class SyncDataStore2<std::string, int>; // test用
extern template class SyncDataStore2<std::shared_ptr<ValueData>, int>;
extern template class SyncDataStore2<std::shared_ptr<TextData>, int>;
extern template class SyncDataStore2<std::shared_ptr<FuncData>, int>;
extern template class SyncDataStore2<std::shared_ptr<message::ViewData>, int>;
extern template class SyncDataStore2<std::shared_ptr<RobotModelData>, int>;
extern template class SyncDataStore2<std::shared_ptr<message::Canvas3DData>,
                                     int>;
extern template class SyncDataStore2<std::shared_ptr<message::Canvas2DData>,
                                     int>;
extern template class SyncDataStore2<ImageData, message::ImageReq>;
extern template class SyncDataStore2<std::shared_ptr<LogData>, int>;
#endif
 
} // namespace internal
WEBCFACE_NS_END