hmbdc
simplify-high-performance-messaging-programming
Messages.hpp
1 #include "hmbdc/Copyright.hpp"
2 #pragma once
3 #include "hmbdc/app/Message.hpp"
4 
5 namespace hmbdc { namespace tips { namespace netmap {
6 
8  uint16_t& messagePayloadLen() {
9  return *reinterpret_cast<uint16_t*>(payload());
10  }
11  uint16_t const& messagePayloadLen() const {
12  return *reinterpret_cast<uint16_t const*>(payload());
13  }
14 
15  //copy message into the right place in memory
16  template <typename M>
18  copyTo(void* addrIn, M&& m) {
19  using Message = typename std::decay<M>::type;
20  auto addr = (char*)addrIn;
21  auto h = reinterpret_cast<TransportMessageHeader*>(addr);
22  new (addr + sizeof(TransportMessageHeader))
23  app::MessageWrap<Message>(std::forward<M>(m));
24  h->messagePayloadLen() = sizeof(app::MessageWrap<Message>);
25  return h;
26  }
27 
29  copyTo(void* addrIn, uint16_t tag, void const* bytes, size_t len) {
30  auto addr = (char*)addrIn;
31  auto h = reinterpret_cast<TransportMessageHeader*>(addr);
32  new (addr + sizeof(TransportMessageHeader)) app::MessageWrap<app::JustBytes>(tag, bytes, len, nullptr);
33  h->messagePayloadLen() = sizeof(app::MessageWrap<app::JustBytes>)
35  return h;
36  }
37 
38  template <typename Message, typename ... Args>
40  copyToInPlace(void* addrIn, Args&&... args) {
41  char* addr = (char*)addrIn;
42  auto h = reinterpret_cast<TransportMessageHeader*>(addr);
43  new (addr + sizeof(TransportMessageHeader)) app::MessageWrap<Message>(std::forward<Args>(args)...);
44  h->messagePayloadLen() = sizeof(app::MessageWrap<Message>);
45  return h;
46  }
47 
48  void const* payload() const {
49  return reinterpret_cast<const char*>(this)
50  + sizeof(TransportMessageHeader);
51  }
52 
53  void * payload() {
54  return reinterpret_cast<char*>(this)
55  + sizeof(TransportMessageHeader);
56  }
57 
58  uint16_t typeTag() const {
59  auto h = static_cast<app::MessageHead const*>(payload());
60  return h->typeTag;
61  }
62 
63  template <typename Message>
64  Message& wrapped() {
65  auto wrap = static_cast<app::MessageWrap<Message>*>(payload());
66  return wrap->payload;
67  }
68 
69  template <typename Message>
70  Message const& wrapped() const {
71  auto wrap = static_cast<app::MessageWrap<Message> const *>(payload());
72  return wrap->payload;
73  }
74 
75  size_t wireSize() const {
76  return sizeof(TransportMessageHeader) + messagePayloadLen();
77  }
78 
79  template <typename Message>
80  static
81  size_t wireSize() {
82  return sizeof(TransportMessageHeader) + sizeof(app::MessageWrap<Message>);
83  }
84 } __attribute__((packed));
85 }}}
Definition: Message.hpp:212
Definition: Message.hpp:263
Definition: Base.hpp:12