cc_tools_qt
Common Environment for Protocol Analysis.
Loading...
Searching...
No Matches
message.h
1//
2// Copyright 2016 - 2025 (C). Alex Robenko. All rights reserved.
3//
4
5// This file is free software: you can redistribute it and/or modify
6// it under the terms of the GNU General Public License as published by
7// the Free Software Foundation, either version 3 of the License, or
8// (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18#pragma once
19
20#include "cc_tools_qt/ToolsApi.h"
21#include "cc_tools_qt/ToolsMessage.h"
22
23#include <QtCore/QObject>
24#include <QtCore/QString>
25#include <QtCore/QVariantMap>
26
27namespace cc_tools_qt
28{
29
30namespace property
31{
32
33namespace message
34{
35
36template <typename TValue>
37class ToolsMsgPropBase
38{
39public:
40 using ValueType = TValue;
41
42 ToolsMsgPropBase(const char* propName)
43 : m_propName(propName)
44 {
45 }
46
47 template <typename U>
48 void setTo(U&& val, QObject& obj) const
49 {
50 obj.setProperty(m_propName, QVariant::fromValue(std::forward<U>(val)));
51 assert(obj.property(m_propName).template canConvert<ValueType>());
52 }
53
54 template <typename U>
55 void setTo(U&& val, QVariantMap& map) const
56 {
57 QString name(m_propName);
58 map.insert(name, QVariant::fromValue(std::forward<U>(val)));
59 assert(map.value(name).template canConvert<ValueType>());
60 }
61
62 ValueType getFrom(const QObject& obj, const ValueType& defaultVal = ValueType()) const
63 {
64 auto var = obj.property(m_propName);
65 if ((!var.isValid()) || (!var.template canConvert<ValueType>())) {
66 return defaultVal;
67 }
68
69 return var.template value<ValueType>();
70 }
71
72 ValueType getFrom(const QVariantMap& map, const ValueType& defaultVal = ValueType()) const
73 {
74 QString name(m_propName);
75 auto var = map.value(name);
76 if ((!var.isValid()) || (!var.template canConvert<ValueType>())) {
77 return defaultVal;
78 }
79
80 return var.template value<ValueType>();
81 }
82
83 void copyFromTo(const QObject& from, QObject& to) const
84 {
85 auto var = from.property(m_propName);
86 if (var.isValid()) {
87 to.setProperty(m_propName, std::move(var));
88 }
89 }
90
91private:
92 const char* m_propName = nullptr;
93};
94
95class CC_TOOLS_API ToolsMsgType : public ToolsMsgPropBase<unsigned>
96{
97 using Base = ToolsMsgPropBase<unsigned>;
98public:
99 using ValueType = ToolsMessage::Type;
100
101 ToolsMsgType();
102
103 template <typename TTo>
104 void setTo(ValueType val, TTo&& to)
105 {
106 Base::setTo(static_cast<Base::ValueType>(val), std::forward<TTo>(to));
107 }
108
109 template <typename TFrom>
110 ValueType getFrom(TFrom&& from)
111 {
112 return static_cast<ValueType>(Base::getFrom(std::forward<TFrom>(from)));
113 }
114};
115
116class CC_TOOLS_API ToolsMsgIdx : public ToolsMsgPropBase<unsigned>
117{
118 using Base = ToolsMsgPropBase<unsigned>;
119public:
120 ToolsMsgIdx();
121};
122
123class CC_TOOLS_API ToolsMsgTimestamp : public ToolsMsgPropBase<unsigned long long>
124{
125 using Base = ToolsMsgPropBase<unsigned long long>;
126public:
127 ToolsMsgTimestamp();
128};
129
130class CC_TOOLS_API ToolsMsgProtocolName : public ToolsMsgPropBase<QString>
131{
132 using Base = ToolsMsgPropBase<QString>;
133public:
134 ToolsMsgProtocolName();
135};
136
137class CC_TOOLS_API ToolsMsgTransportMsg : public ToolsMsgPropBase<ToolsMessagePtr>
138{
139 using Base = ToolsMsgPropBase<ToolsMessagePtr>;
140public:
141 ToolsMsgTransportMsg();
142};
143
144class CC_TOOLS_API ToolsMsgRawDataMsg : public ToolsMsgPropBase<ToolsMessagePtr>
145{
146 using Base = ToolsMsgPropBase<ToolsMessagePtr>;
147public:
148 ToolsMsgRawDataMsg();
149};
150
151class CC_TOOLS_API ToolsMsgExtraInfoMsg : public ToolsMsgPropBase<ToolsMessagePtr>
152{
153 using Base = ToolsMsgPropBase<ToolsMessagePtr>;
154public:
155 ToolsMsgExtraInfoMsg();
156};
157
158class CC_TOOLS_API ToolsMsgExtraInfo : public ToolsMsgPropBase<QVariantMap>
159{
160 using Base = ToolsMsgPropBase<QVariantMap>;
161public:
162 ToolsMsgExtraInfo();
163};
164
165class CC_TOOLS_API ToolsMsgForceExtraInfoExistence : public ToolsMsgPropBase<bool>
166{
167 using Base = ToolsMsgPropBase<bool>;
168public:
169 ToolsMsgForceExtraInfoExistence();
170};
171
172class CC_TOOLS_API ToolsMsgDelay : public ToolsMsgPropBase<unsigned long long>
173{
174 using Base = ToolsMsgPropBase<unsigned long long>;
175public:
176 ToolsMsgDelay();
177};
178
179class CC_TOOLS_API ToolsMsgDelayUnits : public ToolsMsgPropBase<QString>
180{
181 using Base = ToolsMsgPropBase<QString>;
182public:
183 ToolsMsgDelayUnits();
184};
185
186class CC_TOOLS_API ToolsMsgRepeatDuration : public ToolsMsgPropBase<unsigned long long>
187{
188 using Base = ToolsMsgPropBase<unsigned long long>;
189public:
190 ToolsMsgRepeatDuration();
191};
192
193class CC_TOOLS_API ToolsMsgRepeatDurationUnits : public ToolsMsgPropBase<QString>
194{
195 using Base = ToolsMsgPropBase<QString>;
196public:
197 ToolsMsgRepeatDurationUnits();
198};
199
200class CC_TOOLS_API ToolsMsgRepeatCount : public ToolsMsgPropBase<unsigned>
201{
202 using Base = ToolsMsgPropBase<unsigned>;
203public:
204 ToolsMsgRepeatCount();
205};
206
207class CC_TOOLS_API ToolsMsgScrollPos : public ToolsMsgPropBase<int>
208{
209 using Base = ToolsMsgPropBase<int>;
210public:
211 ToolsMsgScrollPos();
212};
213
214class CC_TOOLS_API ToolsMsgComment : public ToolsMsgPropBase<QString>
215{
216 using Base = ToolsMsgPropBase<QString>;
217public:
218 ToolsMsgComment();
219};
220
221} // namespace message
222
223} // namespace property
224
225} // namespace cc_tools_qt
226
Main namespace for all classes / functions of the shared library.