1 #include "hmbdc/Copyright.hpp"
4 #include "hmbdc/comm/Uuid.hpp"
5 #include "hmbdc/time/Time.hpp"
6 #include "hmbdc/Config.hpp"
7 #include "hmbdc/Endian.hpp"
8 #include "hmbdc/MetaUtils.hpp"
13 #include <type_traits>
18 namespace hmbdc {
namespace app {
20 #if __GNUC_PREREQ(9,0)
23 concept MessageC = std::decay<M>::type::typeTag >= 0x0
24 && std::decay<M>::type::typeTag <= 0xffffu;
26 namespace message_detail {
27 template <
typename ...M>
28 constexpr
bool is_message_tuple =
false;
30 template <MessageC ...M>
31 constexpr
bool is_message_tuple<std::tuple<M...>> =
true;
34 template <
typename MT>
35 concept MessageTupleC = message_detail::is_message_tuple<MT>;
37 template <
typename MIter>
38 concept MessageForwardIterC = MessageC<decltype(*(MIter{}))>
39 && requires(MIter it) {++it;};
43 #define MessageC typename
44 #define MessageTupleC typename
45 #define MessageForwardIterC typename
59 template <u
int16_t tag>
64 operator << (std::ostream & os,
hasTag const& t) {
65 return os <<
"hasTag=" << tag << std::endl;
84 template <
typename Message> Message&
get();
85 template <
typename Message> Message
const&
get()
const;
86 template <
typename Message>
void setPayload(Message
const&);
87 template <
typename Message,
typename ...Args>
void setPayloadInPlace(Args&& ... args);
97 uint64_t reserved : 48;
99 } __attribute__((packed));
100 static_assert(
sizeof(Scratchpad) ==
sizeof(reserved2) +
sizeof(reserved),
"");
101 static_assert(
sizeof(Scratchpad::seq) ==
sizeof(reserved2) +
sizeof(reserved),
"");
102 Scratchpad& scratchpad() {
return *
reinterpret_cast<Scratchpad*
>(&reserved2);}
103 Scratchpad
const& scratchpad()
const{
return *
reinterpret_cast<Scratchpad const*
>(&reserved2);}
105 std::ostream& operator << (std::ostream& os,
MessageHead const & h) {
106 return os << h.scratchpad().reserved <<
' ' << h.typeTag;
108 } __attribute__((packed));
109 static_assert(
sizeof(
MessageHead) == 8,
"pakcing issue?");
111 template <
typename Message>
113 template <
typename ...Args>
116 , payload(std::forward<Args>(args)...) {
118 ,
"not a properly defined Message");
130 std::ostream& operator << (std::ostream& os, MessageWrap<Message>
const & w) {
131 return os << static_cast<MessageHead const&>(w) <<
' ' << w.payload;
135 template <
typename Message>
141 template <
typename Message>
143 MessageHead::get()
const{
144 return static_cast<MessageWrap<Message> const*
>(
this)->payload;
147 template <
typename Message>
150 setPayload(Message
const& m) {
151 new (&get<Message>()) Message(m);
152 typeTag = Message::typeTag;
155 template <
typename Message,
typename ...Args>
158 setPayloadInPlace(Args&& ... args) {
159 new (&get<Message>()) Message(std::forward<Args>(args)...);
160 typeTag = Message::typeTag;
167 template <
size_t MaxStreamableSize>
170 char payload[MaxStreamableSize];
171 } __attribute__((__may_alias__, packed));
190 ts[0] = (time::SysTime::now());
195 std::ostream& operator << (std::ostream& os,
Trace const & t) {
196 for (
auto i = 0u; i < t.tsIndex; ++i) os << t.ts[i] <<
' ';
203 MessageWrap(uint16_t tag,
void const* bytes,
size_t len)
205 memcpy(&payload, bytes, len);
210 std::ostream& operator << (std::ostream& os, MessageWrap<JustBytes>
const & w) {
211 return os << static_cast<MessageHead const&>(w) <<
" *";
246 : afterConsumedCleanupFunc(nullptr)
247 , attachment(nullptr)
253 if (afterConsumedCleanupFunc) {
254 afterConsumedCleanupFunc(
this);
255 afterConsumedCleanupFunc =
nullptr;
266 size_t map(
char const* fileName);
267 AfterConsumedCleanupFunc afterConsumedCleanupFunc;
286 return os <<
"hasMemoryAttachment " << m.attachment <<
' ' << m.len;
296 ::free(a->attachment);
297 a->attachment =
nullptr;
299 } __attribute__((aligned (8)));
309 return os <<
"StartAttachmentTrain " << m.underlyingMessageTypeTag
310 <<
' ' << m.att <<
' ' << m.segCount;
312 } __attribute__((aligned(8)));
319 std::ostream& operator << (std::ostream& os,
MemorySeg const & m) {
320 return os <<
"MemorySeg " << m.seg <<
' ' << m.len;
322 } __attribute__((packed));
338 template <MessageC Message>
340 :
hasTag<Message::typeTag> {
344 template <
typename ...Args>
345 explicit REQUEST(Args&&... args)
346 : request(std::forward<Args>(args)...)
362 template <MessageC Message>
364 :
hasTag<Message::typeTag> {
365 template <
typename Request,
typename ...Args>
369 , reply(std::forward<Args>(args)...)
385 MessageWrap(uint16_t tag,
void const* bytes,
size_t len)
387 memcpy(&payload, bytes, len);
392 std::ostream& operator << (std::ostream& os, MessageWrap<REPLY<JustBytes>>
const & w) {
393 return os << static_cast<MessageHead const&>(w) <<
" *";
397 #if __GNUC_PREREQ(9,0)
399 template <
typename R>
400 concept RequestC = hmbdc::is_template<REQUEST, typename std::decay<R>::type>;
401 template <
typename R>
402 concept ReplyC = hmbdc::is_template<REPLY, typename std::decay<R>::type>;
406 #define RequestC typename
407 #define ReplyC typename
Definition: Message.hpp:202
hasMemoryAttachment(char const *fileName)
file mapped memory
Definition: Message.hpp:245
size_t map(char const *fileName)
map this object's attached memory to a file
each message type has 16 bit tag
Definition: Message.hpp:60
hasMemoryAttachment()
default ctor
Definition: Message.hpp:232
template that convert a regular message to be a reply used in request / reply sync messaging - see Re...
Definition: Message.hpp:363
Definition: Message.hpp:168
Definition: Message.hpp:163
Definition: Message.hpp:78
A special type of message only used on the receiving side.
Definition: Message.hpp:182
Definition: Message.hpp:301
hmbdc system messages use tag values less than this one
Definition: Message.hpp:328
Definition: Message.hpp:187
void unmap()
does the reverse of map
Definition: Message.hpp:278
Definition: Message.hpp:112
Definition: Message.hpp:377
Definition: Message.hpp:314
if a specific hmbdc network transport (for example tcpcast, rmcast, and rnetmap) supports message wit...
Definition: Message.hpp:225
template that convert a regular message to be a request used in request / reply sync messaging - see ...
Definition: Message.hpp:339