Belle II Software  release-05-02-19
EvtMessage.cc
1 // +
2 // File : EvtMessage.cc
3 // Description : Low level interface to transfer serialized object
4 //
5 // Author : Soohyung Lee and Ryosuke Itoh
6 // Date : 24 - Jul - 2008
7 // Modified : 9 - Jun - 2010
8 //-
9 
10 #include <framework/pcore/EvtMessage.h>
11 
12 #include <new>
13 #include <cstring>
14 
15 #include <sys/time.h>
16 
17 using namespace std;
18 using namespace Belle2;
19 
20 namespace {
22  int roundToNearestInt(int bytes)
23  {
24  return sizeof(int) * ((bytes + sizeof(int) - 1) / sizeof(int));
25  }
26 }
27 
28 EvtMessage::EvtMessage(char* data):
29  m_data(data),
30  m_ownsBuffer(false)
31 {
32 }
33 
38 EvtMessage::EvtMessage(const char* msg, int size, ERecordType type = MSG_EVENT)
39 {
40  int fullsize = size + sizeof(EvtHeader);
41  int bufsize = roundToNearestInt(fullsize);
42  m_data = new char[bufsize]; // Allocate new buffer
43  // zero extra bytes
44  memset(m_data + fullsize, 0, bufsize - fullsize);
45  setMsg(msg, size, type);
46  m_ownsBuffer = true;
47 }
48 
52 {
53  *this = evtmsg;
54 }
55 
58 {
59  if (m_ownsBuffer)
60  delete [] m_data;
61 }
62 
66 {
67  if (this != &obj) {
68  if (m_ownsBuffer)
69  delete [] m_data;
70  buffer(obj.m_data); //copy m_data
71  m_ownsBuffer = true; //already set by buffer(), but let's be explicit
72  }
73 
74  return *this;
75 }
76 
78 {
79  return m_data;
80 }
81 
82 void EvtMessage::buffer(const char* bufadr)
83 {
84  UInt_t size = *(UInt_t*)bufadr;
85  int bufsize = roundToNearestInt(size);
86  m_data = new char[bufsize];
87  memcpy(m_data, bufadr, size);
88  for (int i = bufsize - size; i > 0; i--)
89  m_data[bufsize - i] = '\0'; //zero extra bytes
90  m_ownsBuffer = true;
91 }
92 
93 // @brief size
94 // @return record size
95 int EvtMessage::size() const
96 {
97  return ((reinterpret_cast<EvtHeader*>(m_data))->size);
98 }
99 
101 {
102  const int sizeBytes = size();
103  //round up to next int boundary
104  return roundToNearestInt(sizeBytes) / sizeof(int);
105 }
106 
107 // @brief msgsize
108 // @return message size
110 {
111  return ((reinterpret_cast<EvtHeader*>(m_data))->size - sizeof(EvtHeader));
112 }
113 
114 // Record type
116 {
117  return ((reinterpret_cast<EvtHeader*>(m_data))->rectype);
118 }
119 
121 {
122  (reinterpret_cast<EvtHeader*>(m_data))->rectype = type;
123 }
124 
125 // Source of this record
126 int EvtMessage::src() const
127 {
128  return ((reinterpret_cast<EvtHeader*>(m_data))->src);
129 }
130 
131 void EvtMessage::src(int src)
132 {
133  (reinterpret_cast<EvtHeader*>(m_data))->src = src;
134 }
135 
136 // Destination of this record
137 int EvtMessage::dest() const
138 {
139  return ((reinterpret_cast<EvtHeader*>(m_data))->dest);
140 }
141 
142 void EvtMessage::dest(int dest)
143 {
144  (reinterpret_cast<EvtHeader*>(m_data))->dest = dest;
145 }
146 
147 // Time stamp
148 struct timeval EvtMessage::time() const {
149  struct timeval tv;
150  tv.tv_sec = (reinterpret_cast<EvtHeader*>(m_data))->time_sec;
151  tv.tv_usec = (reinterpret_cast<EvtHeader*>(m_data))->time_usec;
152  return tv;
153 }
154 
155 void EvtMessage::setTime(const struct timeval& tbuf)
156 {
157  (reinterpret_cast<EvtHeader*>(m_data))->time_sec = tbuf.tv_sec;
158  (reinterpret_cast<EvtHeader*>(m_data))->time_usec = tbuf.tv_usec;
159 }
160 
161 // Event Header
163 {
164  return (reinterpret_cast<EvtHeader*>(m_data));
165 }
166 
168 {
169  return (reinterpret_cast<const EvtHeader*>(m_data));
170 }
171 
172 // Message body
174 {
175  return (m_data + sizeof(EvtHeader));
176 }
177 
178 // set_message
179 
180 void EvtMessage::setMsg(char const* msgin, int size, ERecordType type)
181 {
182  //initialize message header properly
183  new(m_data) EvtHeader(size + sizeof(EvtHeader), type);
184  struct timeval tv;
185  gettimeofday(&tv, nullptr);
186  this->setTime(tv);
187  if (size > 0)
188  memcpy(m_data + sizeof(EvtHeader), msgin, size);
189 }
190 
191 
Belle2::EvtMessage::paddedSize
int paddedSize() const
Same as size(), but as size of an integer array.
Definition: EvtMessage.cc:100
Belle2::EvtMessage::operator=
EvtMessage & operator=(const EvtMessage &obj)
Assignment (m_data is copied).
Definition: EvtMessage.cc:65
Belle2::EvtMessage::m_ownsBuffer
bool m_ownsBuffer
Wether to clean up m_data in destructor.
Definition: EvtMessage.h:150
Belle2::EvtMessage::type
ERecordType type() const
Get record type.
Definition: EvtMessage.cc:115
Belle2::EvtMessage::m_data
char * m_data
Pointer to the internal EvtMessage buffer.
Definition: EvtMessage.h:149
Belle2::EvtMessage
Class to manage streamed object.
Definition: EvtMessage.h:60
Belle2::EvtMessage::dest
int dest() const
Get destination IP of message.
Definition: EvtMessage.cc:137
Belle2::EvtHeader
Header structure of streamed object list.
Definition: EvtMessage.h:29
Belle2::EvtMessage::~EvtMessage
~EvtMessage()
Destructor.
Definition: EvtMessage.cc:57
Belle2::EvtMessage::msg
char * msg()
Get pointer to message body.
Definition: EvtMessage.cc:173
Belle2::EvtMessage::size
int size() const
Get size of message including headers.
Definition: EvtMessage.cc:95
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::EvtMessage::src
int src() const
Get source IP of message.
Definition: EvtMessage.cc:126
Belle2::ERecordType
ERecordType
What type of message is this?
Definition: EvtMessage.h:26
Belle2::EvtMessage::header
EvtHeader * header()
Get pointer to EvtHeader.
Definition: EvtMessage.cc:162
Belle2::EvtMessage::getHeader
const EvtHeader * getHeader() const
Get pointer to EvtHeader.
Definition: EvtMessage.cc:167
Belle2::EvtMessage::setMsg
void setMsg(const char *msg, int size, ERecordType type)
Copy message into newly allocated buffer.
Definition: EvtMessage.cc:180
Belle2::EvtMessage::setTime
void setTime(const struct timeval &time)
Set time stamp.
Definition: EvtMessage.cc:155
Belle2::EvtMessage::buffer
char * buffer()
Get buffer address.
Definition: EvtMessage.cc:77
Belle2::EvtMessage::msg_size
int msg_size() const
Get size of message body.
Definition: EvtMessage.cc:109
Belle2::EvtMessage::EvtMessage
EvtMessage(char *buf=nullptr)
build EvtMessage from existing buffer (no copy, but does not take ownership).
Definition: EvtMessage.cc:28