libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
messages_impl.hpp
Go to the documentation of this file.
1 /******************************************************************************
2 ** Copyright © 2015 by J.M.McGuiness, isimud@hussar.me.uk
3 **
4 ** This library is free software; you can redistribute it and/or
5 ** modify it under the terms of the GNU Lesser General Public
6 ** License as published by the Free Software Foundation; either
7 ** version 2.1 of the License, or (at your option) any later version.
8 **
9 ** This library is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 ** Lesser General Public License for more details.
13 **
14 ** You should have received a copy of the GNU Lesser General Public
15 ** License along with this library; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 
19 namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace BATSBOE { namespace common {
20 
21 template<class MsgT, MsgT Msg> inline
22 Header<MsgT, Msg>::Header(std::size_t l) noexcept(true)
23 : length_(static_cast<std::uint16_t>(l)-sizeof(std::uint16_t)), sequenceNumber() {
24  assert(l<std::numeric_limits<std::uint16_t>::max());
25  assert((length_+sizeof(std::uint16_t))>=sizeof(Header));
26 }
27 
28 template<class MsgT, MsgT Msg> inline
29 Header<MsgT, Msg>::Header(std::size_t l, SeqNum_t seqNum) noexcept(true)
30 : length_(static_cast<std::uint16_t>(l)-sizeof(std::uint16_t)), sequenceNumber(seqNum) {
31  assert(l<std::numeric_limits<std::uint16_t>::max());
32  assert((length_+sizeof(std::uint16_t))>=sizeof(Header));
33 }
34 
35 template<class MsgT, MsgT Msg> inline std::uint16_t
36 Header<MsgT, Msg>::length() const noexcept(true) {
37  const std::uint16_t l=length_+sizeof(std::uint16_t);
38  assert(l>=sizeof(Header));
39  return l;
40 }
41 
42 template<class MsgT, MsgT Msg> inline
43 LogonRequest<MsgT, Msg>::LogonRequest(SeqNum_t seqNum, const SessionSubID_t ssID, const UserName_t &UN, const Password_t &P, const bool noUnspec) noexcept(true)
44 : Header_t(sizeof(LogonRequest), seqNum), sessionSubID(ssID), userName(UN), password(P), noUnspecifiedUnitReplay(noUnspec) {
45 }
46 
47 template<class MsgT, MsgT Msg> inline
48 LogonRequest<MsgT, Msg>::LogonRequest(logon_args_t const &a) noexcept(true)
49 : LogonRequest(a.sequenceNumber, a.sessionSubID, a.username, a.password, a.noUnspec) {
50 }
51 
52 inline
53 LogoutRequest::LogoutRequest(SeqNum_t seqNum) noexcept(true)
54 : Header_t(sizeof(LogoutRequest), seqNum) {
55 }
56 
57 inline
58 LogoutRequest::LogoutRequest(logoff_args_t const &a) noexcept(true)
59 : LogoutRequest(a.sequenceNumber) {
60 }
61 
62 inline
63 ClientHeartbeat::ClientHeartbeat(SeqNum_t seqNum) noexcept(true)
64 : Header_t(sizeof(ClientHeartbeat), seqNum) {
65 }
66 
67 template<class MsgT, MsgT Msg> inline
68 LogonReply<MsgT, Msg>::LogonReply() noexcept(true)
69 : Header_t(sizeof(LogonReply)) {
70 }
71 
72 template<class MsgT, MsgT Msg> inline
73 LogonReply<MsgT, Msg>::LogonReply(SeqNum_t seqNum) noexcept(true)
74 : Header_t(sizeof(LogonReply), seqNum) {
75 }
76 
77 template<class MsgT, MsgT Msg>
78 struct LogonReply<MsgT, Msg>::respond {
79  template<class ReplyMsg, class Op> void
80  operator()(ReplyMsg const &msg, Op const &o) const noexcept(false) FORCE_INLINE {
81  switch (msg.rejectCode()) {
82  case ReplyMsg::logon_success:
83  o.operator()();
84  break;
85  default: {
86  std::ostringstream os;
87  os<<"Failed to logon. Reject code="<<msg.rejectCode();
88  assert(!"TODO need reject code as string.");
89  throw std::runtime_error(os.str());
90  }
91  }
92  }
93 };
94 
95 inline
96 Logout::Logout() noexcept(true)
97 : Header_t(sizeof(Logout)) {
98 }
99 
100 inline
101 Logout::Logout(SeqNum_t seqNum, LogoutReason lr) noexcept(true)
102 : Header_t(sizeof(Logout), seqNum), logoutReason(lr) {
103 }
104 
105 inline
106 ServerHeartbeat::ServerHeartbeat(SeqNum_t seqNum) noexcept(true)
107 : Header_t(sizeof(ServerHeartbeat), seqNum) {
108 }
109 
110 inline
111 ReplayComplete::ReplayComplete(SeqNum_t seqNum) noexcept(true)
112 : Header_t(sizeof(ReplayComplete), seqNum) {
113 }
114 
115 inline
116 NewOrder::NewOrder(SeqNum_t seqNum, ClientOrderID_t const &clID, OrdType const oT, TIF const t, Side const s, SecurityID_t instID, common::Quantity_t ordQty, Price_t p) noexcept(true)
117 : Header_t(sizeof(NewOrder)-sizeof(bitfields_to_type_map), seqNum), side_(s), orderQty_(ordQty) {
118  libjmmcg::memcpy_opt(clID, clientOrderID_);
119  bitfields.push_back<bitfields_tags_type::Price>(p);
120  bitfields.push_back<bitfields_tags_type::OrdType>(oT);
121  bitfields.push_back<bitfields_tags_type::TimeInForce>(t);
122  bitfields.push_back<bitfields_tags_type::SecurityID>(instID);
123  length_+=bitfields.size();
124 }
125 
126 inline OrdType const &
127 NewOrder::orderType() const noexcept(true) {
128  return bitfields.at<bitfields_tags_type::OrdType>();
129 }
130 
131 inline void
132 NewOrder::orderType(OrdType const &i) noexcept(true) {
133  bitfields.at<bitfields_tags_type::OrdType>()=i;
134 }
135 
136 inline SecurityID_t const &
137 NewOrder::instrumentID() const noexcept(true) {
138  return bitfields.at<bitfields_tags_type::SecurityID>();
139 }
140 
141 inline void
142 NewOrder::instrumentID(SecurityID_t const &i) noexcept(true) {
143  libjmmcg::memcpy_opt(i, bitfields.at<bitfields_tags_type::SecurityID>());
144 }
145 
146 inline Price_t
147 NewOrder::limitPrice() const noexcept(true) {
148  return bitfields.at<bitfields_tags_type::Price>();
149 }
150 
151 inline void
152 NewOrder::limitPrice(Price_t p) noexcept(true) {
153  bitfields.at<bitfields_tags_type::Price>()=p;
154 }
155 
156 inline TIF
157 NewOrder::tif() const noexcept(true) {
158  return bitfields.at<bitfields_tags_type::TimeInForce>();
159 }
160 
161 inline void
162 NewOrder::tif(TIF t) noexcept(true) {
163  bitfields.at<bitfields_tags_type::TimeInForce>()=t;
164 }
165 
166 inline
167 CancelOrder::CancelOrder(SeqNum_t seqNum, ClientOrderID_t const &origclID) noexcept(true)
168 : Header_t(sizeof(CancelOrder)-sizeof(bitfields_to_type_map), seqNum) {
169  libjmmcg::memcpy_opt(origclID, originalClientOrderID_);
170  length_+=bitfields.size();
171 }
172 
173 inline
174 ModifyOrder::ModifyOrder(SeqNum_t seqNum, ClientOrderID_t const &clID, common::Quantity_t ordQty, Price_t p, Side s) noexcept(true)
175 : Header_t(sizeof(ModifyOrder)-sizeof(bitfields_to_type_map), seqNum) {
176  libjmmcg::memcpy_opt(clID, originalClientOrderID_);
177  bitfields.push_back<bitfields_tags_type::OrderQty>(ordQty);
178  bitfields.push_back<bitfields_tags_type::Price>(p);
179  bitfields.push_back<bitfields_tags_type::Side>(s);
180  length_+=bitfields.size();
181 }
182 
183 inline Price_t
184 ModifyOrder::limitPrice() const noexcept(true) {
185  return bitfields.at<bitfields_tags_type::Price>();
186 }
187 
188 inline void
189 ModifyOrder::limitPrice(Price_t p) noexcept(true) {
190  bitfields.at<bitfields_tags_type::Price>()=p;
191 }
192 
193 inline common::Quantity_t
194 ModifyOrder::orderQty() const noexcept(true) {
195  return bitfields.at<bitfields_tags_type::OrderQty>();
196 }
197 
198 inline void
199 ModifyOrder::orderQty(common::Quantity_t i) noexcept(true) {
200  bitfields.at<bitfields_tags_type::OrderQty>()=i;
201 }
202 
203 inline Side
204 ModifyOrder::side() const noexcept(true) {
205  return bitfields.at<bitfields_tags_type::Side>();
206 }
207 
208 inline void
209 ModifyOrder::side(Side i) noexcept(true) {
210  bitfields.at<bitfields_tags_type::Side>()=i;
211 }
212 
213 inline
214 OrderAcknowledgement::OrderAcknowledgement(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true)
215 : Header_t(sizeof(OrderAcknowledgement)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) {
216  libjmmcg::memcpy_opt(clID, clientOrderID_);
217  length_+=bitfields.size();
218 }
219 
220 inline
221 OrderRejected::OrderRejected() noexcept(true)
222 : Header_t(sizeof(OrderRejected)-sizeof(bitfields_to_type_map)), transactionTime(), orderRejectReason() {
223  length_+=bitfields.size();
224 }
225 
226 inline
227 OrderRejected::OrderRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr) noexcept(true)
228 : Header_t(sizeof(OrderRejected)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()), orderRejectReason(orr) {
229  libjmmcg::memcpy_opt(clID, clientOrderID_);
230  length_+=bitfields.size();
231 }
232 
233 inline
234 OrderModified::OrderModified() noexcept(true)
235 : Header_t(sizeof(OrderModified)-sizeof(bitfields_to_type_map)), transactionTime() {
236  length_+=bitfields.size();
237 }
238 
239 inline
240 OrderModified::OrderModified(SeqNum_t seqNum, ClientOrderID_t const &clID, Price_t p, Side s, common::Quantity_t ordQty) noexcept(true)
241 : Header_t(sizeof(OrderModified)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) {
242  libjmmcg::memcpy_opt(clID, clientOrderID_);
243  bitfields.push_back<bitfields_tags_type::Side>(s);
244  bitfields.push_back<bitfields_tags_type::Price>(p);
245  bitfields.push_back<bitfields_tags_type::OrderQuantity>(ordQty);
246  length_+=bitfields.size();
247 }
248 
249 inline Price_t
250 OrderModified::limitPrice() const noexcept(true) {
251  return bitfields.at<bitfields_tags_type::Price>();
252 }
253 
254 inline void
255 OrderModified::limitPrice(Price_t p) noexcept(true) {
256  bitfields.at<bitfields_tags_type::Price>()=p;
257 }
258 
259 inline common::Quantity_t
260 OrderModified::orderQty() const noexcept(true) {
261  return bitfields.at<bitfields_tags_type::OrderQuantity>();
262 }
263 
264 inline void
265 OrderModified::orderQty(common::Quantity_t i) noexcept(true) {
266  bitfields.at<bitfields_tags_type::OrderQuantity>()=i;
267 }
268 
269 inline Side
270 OrderModified::side() const noexcept(true) {
271  return bitfields.at<bitfields_tags_type::Side>();
272 }
273 
274 inline void
275 OrderModified::side(Side i) noexcept(true) {
276  bitfields.at<bitfields_tags_type::Side>()=i;
277 }
278 
279 inline
280 OrderRestated::OrderRestated(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true)
281 : Header_t(sizeof(OrderRestated)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) {
282  libjmmcg::memcpy_opt(clID, clientOrderID_);
283  length_+=bitfields.size();
284 }
285 
286 inline
287 UserModifyRejected::UserModifyRejected() noexcept(true)
288 : Header_t(sizeof(UserModifyRejected)-sizeof(bitfields_to_type_map)), transactionTime(), modifyRejectReason() {
289  length_+=bitfields.size();
290 }
291 
292 inline
293 UserModifyRejected::UserModifyRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr) noexcept(true)
294 : Header_t(sizeof(UserModifyRejected)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()), modifyRejectReason(orr) {
295  libjmmcg::memcpy_opt(clID, clientOrderID_);
296  length_+=bitfields.size();
297 }
298 
299 inline
300 OrderCancelled::OrderCancelled() noexcept(true)
301 : Header_t(sizeof(OrderCancelled)-sizeof(bitfields_to_type_map)), transactionTime(), cancelReason() {
302  length_+=bitfields.size();
303 }
304 
305 inline
306 OrderCancelled::OrderCancelled(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr, Price_t p, Side s, common::Quantity_t ls, common::Quantity_t ordQty) noexcept(true)
307 : Header_t(sizeof(OrderCancelled)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()), cancelReason(orr) {
308  libjmmcg::memcpy_opt(clID, clientOrderID_);
309  bitfields.push_back<bitfields_tags_type::Side>(s);
310  bitfields.push_back<bitfields_tags_type::OrderQuantity>(ordQty);
311  bitfields.push_back<bitfields_tags_type::LeavesQty>(ordQty);
312  bitfields.push_back<bitfields_tags_type::LastShares>(ls);
313  bitfields.push_back<bitfields_tags_type::LastPx>(p);
314  length_+=bitfields.size();
315 }
316 
317 inline Side
318 OrderCancelled::side() const noexcept(true) {
319  return bitfields.at<bitfields_tags_type::Side>();
320 }
321 
322 inline common::Quantity_t
323 OrderCancelled::orderQty() const noexcept(true) {
324  return bitfields.at<bitfields_tags_type::OrderQuantity>();
325 }
326 
327 inline common::Quantity_t
328 OrderCancelled::leavesQty() const noexcept(true) {
329  return bitfields.at<bitfields_tags_type::LeavesQty>();
330 }
331 
332 inline common::Quantity_t
333 OrderCancelled::lastShares() const noexcept(true) {
334  return bitfields.at<bitfields_tags_type::LastShares>();
335 }
336 
337 inline Price_t
338 OrderCancelled::lastPrice() const noexcept(true) {
339  return bitfields.at<bitfields_tags_type::LastPx>();
340 }
341 
342 inline
343 CancelRejected::CancelRejected() noexcept(true)
344 : Header_t(sizeof(CancelRejected)-sizeof(bitfields_to_type_map)), transactionTime(), cancelRejectReason() {
345  length_+=bitfields.size();
346 }
347 
348 inline
349 CancelRejected::CancelRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason crr) noexcept(true)
350 : Header_t(sizeof(CancelRejected)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()), cancelRejectReason(crr) {
351  libjmmcg::memcpy_opt(clID, clientOrderID_);
352  length_+=bitfields.size();
353 }
354 
355 inline
356 OrderExecution::OrderExecution() noexcept(true)
357 : Header_t(sizeof(OrderExecution)-sizeof(bitfields_to_type_map)), transactionTime() {
358  length_+=bitfields.size();
359 }
360 
361 inline
362 OrderExecution::OrderExecution(SeqNum_t seqNum, ClientOrderID_t const &clID, Price_t const price, SecurityID_t const &instID, Side s) noexcept(true)
363 : Header_t(sizeof(OrderExecution)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()), lastPx(price) {
364  libjmmcg::memcpy_opt(clID, clientOrderID_);
365  bitfields.push_back<bitfields_tags_type::Side>(s);
366  bitfields.push_back<bitfields_tags_type::SecurityID>(instID);
367  length_+=bitfields.size();
368 }
369 
370 inline SecurityID_t const &
371 OrderExecution::instrumentID() const noexcept(true) {
372  return bitfields.at<bitfields_tags_type::SecurityID>();
373 }
374 
375 inline void
376 OrderExecution::instrumentID(SecurityID_t const &i) noexcept(true) {
377  libjmmcg::memcpy_opt(i, bitfields.at<bitfields_tags_type::SecurityID>());
378 }
379 
380 inline Side
381 OrderExecution::side() const noexcept(true) {
382  return bitfields.at<bitfields_tags_type::Side>();
383 }
384 
385 inline void
386 OrderExecution::side(Side s) noexcept(true) {
387  bitfields.at<bitfields_tags_type::Side>()=s;
388 }
389 
390 inline
391 TradeCancelOrCorrect::TradeCancelOrCorrect(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true)
392 : Header_t(sizeof(TradeCancelOrCorrect)-sizeof(bitfields_to_type_map), seqNum), transactionTime(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) {
393  libjmmcg::memcpy_opt(clID, clientOrderID_);
394  length_+=bitfields.size();
395 }
396 
397 } } } } }