publishcopyfactory.cpp
4.03 KB
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#include <cassert>
#include "publishcopyfactory.h"
#include "mqttpacket.h"
PublishCopyFactory::PublishCopyFactory(MqttPacket *packet) :
packet(packet),
orgQos(packet->getQos())
{
}
PublishCopyFactory::PublishCopyFactory(Publish *publish) :
publish(publish),
orgQos(publish->qos)
{
}
MqttPacket *PublishCopyFactory::getOptimumPacket(const char max_qos, const ProtocolVersion protocolVersion, uint16_t topic_alias, bool skip_topic)
{
const char actualQos = getEffectiveQos(max_qos);
if (packet)
{
if (protocolVersion >= ProtocolVersion::Mqtt5 && (packet->containsClientSpecificProperties() || topic_alias > 0))
{
Publish newPublish(packet->getPublishData());
newPublish.qos = actualQos;
newPublish.topicAlias = topic_alias;
newPublish.skipTopic = skip_topic;
this->oneShotPacket = std::make_unique<MqttPacket>(protocolVersion, newPublish);
return this->oneShotPacket.get();
}
if (packet->getProtocolVersion() == protocolVersion && static_cast<bool>(orgQos) == static_cast<bool>(actualQos))
{
return packet;
}
const int cache_key = (static_cast<uint8_t>(protocolVersion) * 10) + actualQos;
std::unique_ptr<MqttPacket> &cachedPack = constructedPacketCache[cache_key];
if (!cachedPack)
{
Publish newPublish(packet->getPublishData());
newPublish.qos = actualQos;
cachedPack = std::make_unique<MqttPacket>(protocolVersion, newPublish);
}
return cachedPack.get();
}
// Getting an instance of a Publish object happens at least on retained messages, will messages and SYS topics. It's low traffic, anyway.
assert(publish);
publish->qos = actualQos;
this->oneShotPacket = std::make_unique<MqttPacket>(protocolVersion, *publish);
return this->oneShotPacket.get();
}
char PublishCopyFactory::getEffectiveQos(char max_qos) const
{
const char effectiveQos = std::min<char>(orgQos, max_qos);
return effectiveQos;
}
const std::string &PublishCopyFactory::getTopic() const
{
if (packet)
return packet->getTopic();
assert(publish);
return publish->topic;
}
const std::vector<std::string> &PublishCopyFactory::getSubtopics()
{
if (packet)
{
return packet->getSubtopics();
}
else if (publish)
{
return publish->getSubtopics();
}
throw std::runtime_error("Bug in &PublishCopyFactory::getSubtopics()");
}
bool PublishCopyFactory::getRetain() const
{
if (packet)
return packet->getRetain();
assert(publish);
return publish->retain;
}
/**
* @brief PublishCopyFactory::getNewPublish gets a new publish object from an existing packet or publish.
* @param new_max_qos
* @return
*
* It being a public function, the idea is that it's only needed for creating publish objects for storing QoS messages for off-line
* clients. For on-line clients, you're always making a packet (with getOptimumPacket()).
*/
Publish PublishCopyFactory::getNewPublish(char new_max_qos) const
{
// (At time of writing) we only need to construct new publishes for QoS (because we're storing QoS publishes for offline clients). If
// you're doing it elsewhere, it's a bug.
assert(orgQos > 0);
assert(new_max_qos > 0);
const char actualQos = getEffectiveQos(new_max_qos);
if (packet)
{
assert(packet->getQos() > 0);
Publish p(packet->getPublishData());
p.qos = actualQos;
return p;
}
assert(publish->qos > 0); // Same check as above, but then for Publish objects.
Publish p(*publish);
p.qos = actualQos;
return p;
}
std::shared_ptr<Client> PublishCopyFactory::getSender()
{
if (packet)
return packet->getSender();
return std::shared_ptr<Client>(0);
}
const std::vector<std::pair<std::string, std::string> > *PublishCopyFactory::getUserProperties() const
{
if (packet)
{
return packet->getUserProperties();
}
assert(publish);
return publish->getUserProperties();
}