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
|
// Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#include "iceoryx_posh/popo/rpc_header.hpp"
#include "iceoryx_posh/mepoo/chunk_header.hpp"
namespace iox
{
namespace popo
{
RpcBaseHeader::RpcBaseHeader(const cxx::UniqueId& uniqueClientQueueId,
const uint32_t lastKnownClientQueueIndex,
const int64_t sequenceId,
const uint8_t rpcHeaderVersion) noexcept
: m_rpcHeaderVersion(rpcHeaderVersion)
, m_lastKnownClientQueueIndex(lastKnownClientQueueIndex)
, m_uniqueClientQueueId(uniqueClientQueueId)
, m_sequenceId(sequenceId)
{
}
uint8_t RpcBaseHeader::getRpcHeaderVersion() const noexcept
{
return m_rpcHeaderVersion;
}
int64_t RpcBaseHeader::getSequenceId() const noexcept
{
return m_sequenceId;
}
mepoo::ChunkHeader* RpcBaseHeader::getChunkHeader() noexcept
{
return mepoo::ChunkHeader::fromUserHeader(this);
}
const mepoo::ChunkHeader* RpcBaseHeader::getChunkHeader() const noexcept
{
return mepoo::ChunkHeader::fromUserHeader(this);
}
void* RpcBaseHeader::getUserPayload() noexcept
{
return mepoo::ChunkHeader::fromUserHeader(this)->userPayload();
}
const void* RpcBaseHeader::getUserPayload() const noexcept
{
return mepoo::ChunkHeader::fromUserHeader(this)->userPayload();
}
RequestHeader::RequestHeader(const cxx::UniqueId& uniqueClientQueueId,
const uint32_t lastKnownClientQueueIndex) noexcept
: RpcBaseHeader(uniqueClientQueueId, lastKnownClientQueueIndex, START_SEQUENCE_ID, RPC_HEADER_VERSION)
{
}
void RequestHeader::setSequenceId(const int64_t sequenceId) noexcept
{
this->m_sequenceId = sequenceId;
}
RequestHeader* RequestHeader::fromPayload(void* const payload) noexcept
{
auto chunkHeader = mepoo::ChunkHeader::fromUserPayload(payload);
return chunkHeader ? static_cast<RequestHeader*>(chunkHeader->userHeader()) : nullptr;
}
const RequestHeader* RequestHeader::fromPayload(const void* const payload) noexcept
{
auto chunkHeader = mepoo::ChunkHeader::fromUserPayload(payload);
return chunkHeader ? static_cast<const RequestHeader*>(chunkHeader->userHeader()) : nullptr;
}
ResponseHeader::ResponseHeader(const cxx::UniqueId& uniqueClientQueueId,
const uint32_t lastKnownClientQueueIndex,
const int64_t sequenceId) noexcept
: RpcBaseHeader(uniqueClientQueueId, lastKnownClientQueueIndex, sequenceId, RPC_HEADER_VERSION)
{
}
void ResponseHeader::setServerError() noexcept
{
m_hasServerError = true;
}
bool ResponseHeader::hasServerError() const noexcept
{
return m_hasServerError;
}
ResponseHeader* ResponseHeader::fromPayload(void* const payload) noexcept
{
auto chunkHeader = mepoo::ChunkHeader::fromUserPayload(payload);
return chunkHeader ? static_cast<ResponseHeader*>(chunkHeader->userHeader()) : nullptr;
}
const ResponseHeader* ResponseHeader::fromPayload(const void* const payload) noexcept
{
auto chunkHeader = mepoo::ChunkHeader::fromUserPayload(payload);
return chunkHeader ? static_cast<const ResponseHeader*>(chunkHeader->userHeader()) : nullptr;
}
} // namespace popo
} // namespace iox
|
