grpc-labview/src/lv_message_efficient.h at b831d1966290d0130b2a345325588d73e269243e · ni/grpc-labview · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
//---------------------------------------------------------------------
//---------------------------------------------------------------------
#pragma once

//---------------------------------------------------------------------
//---------------------------------------------------------------------
#include <message_value.h>
#include <message_metadata.h>
#include <google/protobuf/message.h>
#include <lv_message.h>
#include <well_known_messages.h>

using namespace google::protobuf::internal;

namespace grpc_labview
{
    //---------------------------------------------------------------------
    //---------------------------------------------------------------------
    class LVMessageEfficient : public LVMessage
    {
    public:
        LVMessageEfficient(std::shared_ptr<MessageMetadata> metadata, int8_t* cluster) : LVMessage(metadata), _LVClusterHandle(cluster) {}
        ~LVMessageEfficient() {}

        Message* New(google::protobuf::Arena* arena) const override;
        void PostInteralParseAction() override;
        int8_t* GetLVClusterHandle() { return _LVClusterHandle; };

    protected:
        struct RepeatedMessageValue {
            const MessageElementMetadata& _fieldInfo;
            google::protobuf::RepeatedField<char> _buffer;
            uint64_t _numElements = 0;

            RepeatedMessageValue(const MessageElementMetadata& fieldInfo, google::protobuf::RepeatedField<char> buffer) :
                _fieldInfo(fieldInfo), _buffer(buffer) {}
        };

        struct RepeatedStringValue {
            const MessageElementMetadata& _fieldInfo;
            google::protobuf::RepeatedField<std::string> _repeatedString;

            RepeatedStringValue(const MessageElementMetadata& fieldInfo) :
                _fieldInfo(fieldInfo), _repeatedString(google::protobuf::RepeatedField<std::string>()) {}
        };

    public:
        std::unordered_map<std::string, std::shared_ptr<RepeatedMessageValue>> _repeatedMessageValuesMap;
        std::unordered_map<std::string, std::shared_ptr<RepeatedStringValue>> _repeatedStringValuesMap;

    protected:
        int8_t* _LVClusterHandle;

        const char* ParseBoolean(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseInt32(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseUInt32(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseEnum(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseInt64(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseUInt64(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseFloat(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseDouble(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseSInt32(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseSInt64(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseFixed32(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseFixed64(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseSFixed32(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseSFixed64(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseString(unsigned int tag, const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseBytes(unsigned int tag, const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseNestedMessage(google::protobuf::uint32 tag, const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx) override;
        const char* ParseDouble2DArrayMessage(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx);
        const char* ParseString2DArrayMessage(const MessageElementMetadata& fieldInfo, uint32_t index, const char* ptr, google::protobuf::internal::ParseContext* ctx);

    private:
        const char* Parse2DArrayMessage(const MessageElementMetadata& fieldInfo, uint32_t index, const char* protobuf_ptr, ParseContext* ctx, wellknown::I2DArray& array);
    };

    template <typename MessageType, const char* (*ReadFunc)(const char*, MessageType*), const char* (*PackedFunc)(void*, const char*, google::protobuf::internal::ParseContext*)>
    class SinglePassMessageParser {
    private:
        LVMessageEfficient& _message;
        int8_t* _lv_ptr;
    public:
        // Constructor and other necessary member functions
        SinglePassMessageParser(LVMessageEfficient& message, const MessageElementMetadata& fieldInfo) : _message(message) {
            _lv_ptr = _message.GetLVClusterHandle() + fieldInfo.clusterOffset;
        }

        // Parse and copy message in a single pass.
        template<typename RepeatedMessageValuePointer>
        const char* ParseAndCopyRepeatedMessage(const char* ptr, ParseContext* ctx, RepeatedMessageValuePointer v) {

            uint64_t numElements;
            ptr = PackedMessageType(ptr, ctx, reinterpret_cast<google::protobuf::RepeatedField<MessageType>*>(&(v->_value)));
            numElements = v->_value.size();
            // get the LVClusterHandle

            // ContinueIndex is not required here as the _value vector created is of the corresponding type, and is not being used a buffer.
            // PackedMessageType will just be able to push_back or add the later parsed data to the type vector.

            // copy into LVCluster
            if (numElements != 0)
            {
                auto messageTypeSize = sizeof(MessageType);
                NumericArrayResize(GetTypeCodeForSize(messageTypeSize), 1, _lv_ptr, numElements);
                auto array = *(LV1DArrayHandle*)_lv_ptr;
                (*array)->cnt = numElements;
                auto byteCount = numElements * messageTypeSize;
                std::memcpy((*array)->bytes<MessageType>(), v->_value.data(), byteCount);
            }

            return ptr;
        }

        const char* PackedMessageType(const char* ptr, ParseContext* ctx, google::protobuf::RepeatedField<MessageType>* value)
        {
            return PackedFunc(value, ptr, ctx);
        }

        const char* ParseAndCopyMessage(const char* ptr) {
            ptr = ReadMessageType(ptr, reinterpret_cast<MessageType*>(_lv_ptr));
            return ptr;
        }

        const char* ReadMessageType(const char* ptr, MessageType* lv_ptr)
        {
            return ReadFunc(ptr, lv_ptr);
        }
    };
}