Files
spark/src/lib/md/Shm/FixedSecurity.h
T

283 lines
8.4 KiB
C++

#pragma once
#include "../common.h"
#include "lib/utils/bts_export.h"
#include "lib/utils/warn_ctrl.h"
#include "lib/utils/bts_array_size.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_no_copy.h"
#include "lib/utils/ValueWrapper.h"
#include <string>
#include <sstream>
namespace bts {
namespace md {
using SecurityKey = utils::ValueWrapper<struct SecurityKeyTag,uint32_t>;
using ExchangeKey = utils::ValueWrapper<struct ExchangeKeyTag,uint64_t>;
GCC_DIAG_OFF("-Weffc++") // No Virtual Destructors by design
#define STRING_PROPERTY(NAME) const char* NAME() const { return _##NAME; } \
void NAME(const char* val, size_t size) { strncpy(_##NAME, val, std::min(BTS_ARRAYSIZE(_##NAME)-1, size)); _##NAME[std::min(BTS_ARRAYSIZE(_##NAME)-1, size)] = '\0'; } \
void NAME(const std::string& val) { NAME(val.c_str(), val.size()); }
struct ColdEntry;
// Caution: FixedSecurity is a variable sized structure
// Use FixedSecurity::size to determine size not sizeof()
class BTS_EXPORT FixedSecurity
{
protected:
FixedSecurity();
friend ColdEntry;
public:
FixedSecurity(const FixedSecurity&) = delete;
~FixedSecurity();
STRING_PROPERTY(symbol);
STRING_PROPERTY(alt_symbol);
STRING_PROPERTY(cfi_code);
STRING_PROPERTY(security_desc);
STRING_PROPERTY(platform_id);
size_t size;
security_key key;
uint64_t numeric_id;
api::SecurityType type;
api::Venue exchange;
int8_t display_factor;
double price_break;
double low_tick;
double high_tick;
double cash_per_point;
uint32_t cboe_class_key;
uint8_t cme_market_segment_id;
uint8_t cme_main_fraction;
uint8_t cme_sub_fraction;
uint8_t cme_price_display_format;
int8_t ice_price_denominator;
int8_t ice_deal_denominator;
int8_t ice_settle_denominator;
bool is_ice_strip;
STRING_PROPERTY(ice_market_description);
STRING_PROPERTY(ice_cleared_alias);
STRING_PROPERTY(ice_product_name);
STRING_PROPERTY(ice_hub_alias);
STRING_PROPERTY(ice_strip_name);
STRING_PROPERTY(mic_code);
private:
char _symbol[16]; // CME defines this as a char[6] but I'm padding
char _cfi_code[8]; // CME defines this as char[6]
char _security_desc[32]; // cme security desc FIX=107 //ice wants this to be 35
char _alt_symbol[16]; // "cme symbol" or alternate symbol
char _platform_id[64];
char _ice_market_description[120];
char _ice_cleared_alias[15];
char _ice_product_name[62];
char _ice_hub_alias[80];
char _ice_strip_name[39];
char _mic_code[4];
};
class FixedStockSecurity : public FixedSecurity {
public:
FixedStockSecurity() {
type = api::SECURITYTYPE_STOCK;
};
};
class BTS_EXPORT FixedFutureSecurity : public FixedSecurity
{
public:
FixedFutureSecurity();
uint32_t expiration_year;
uint32_t expiration_month;
uint32_t expiration_day;
};
class BTS_EXPORT FixedOptionSecurity : public FixedSecurity
{
public:
FixedOptionSecurity();
uint32_t expiration_year;
uint32_t expiration_month;
uint32_t expiration_day;
double strike;
api::PutOrCall call_put;
};
struct BTS_EXPORT FixedSpreadLeg
{
FixedSpreadLeg();
security_key key;
ExchangeKey exchange_key;
Side leg_side;
double leg_quantity;
double leg_price;
double leg_delta;
};
template <int LEGCOUNT=16>
class FixedSpreadSecurity : public FixedSecurity
{
char _summary[128];
public:
FixedSpreadSecurity() : _leg_count(0), _leg_max(LEGCOUNT), legs() {
type = api::SECURITYTYPE_SPREAD;
size = sizeof(FixedSpreadSecurity<1>);
memset(&_summary, 0, BTS_ARRAYSIZE(_summary));
}
void set_leg_count(size_t count) {
bts_assert(count > 0);
bts_assert(count <= LEGCOUNT);
bts_assert(count <= _leg_max);
_leg_count = count;
size = sizeof(FixedSpreadSecurity<1>) + (sizeof(FixedSpreadLeg) * (count - 1));
}
STRING_PROPERTY(summary);
static size_t static_count() { return LEGCOUNT; }
uint32_t leg_count() const { return _leg_count; }
private:
// memcpy only please
uint32_t _leg_count;
uint32_t _leg_max;
BTS_NO_COPY(FixedSpreadSecurity);
public:
// NO members after legs array
FixedSpreadLeg legs[LEGCOUNT];
};
// We store the normalized legs for a normal spread because they aren't available when it is created
// A synthetic security is always fully defined
class FixedSyntheticSecurity : public FixedSecurity
{
public:
FixedSyntheticSecurity(const api::Security& sec) :
_leg_count(sec.synthetic().legs_size()),
_buffer_size(sec.ByteSize())
{
type = api::SECURITYTYPE_SYNTHETIC;
sec.SerializeToArray(buffer(), _buffer_size);
size = sizeof(FixedSyntheticSecurity) + _buffer_size;
}
uint32_t leg_count() const { return _leg_count; }
uint32_t buffer_size() const { return _buffer_size; }
void deserialize(api::Security& dest) const {
dest.ParseFromArray(buffer(), _buffer_size);
}
private:
uint8_t* buffer() {
return (reinterpret_cast<uint8_t*>(this) + sizeof(FixedSyntheticSecurity));
}
const uint8_t* buffer() const {
return (reinterpret_cast<const uint8_t*>(this) + sizeof(FixedSyntheticSecurity));
}
uint32_t _leg_count;
uint32_t _buffer_size;
};
// Stack allocate a FixedSpreadSecurity with a high number of legs then memcpy the right size to shared memory
typedef FixedSpreadSecurity<2> FixedSpreadSecurityXS;
typedef FixedSpreadSecurity<16> FixedSpreadSecurityS;
typedef FixedSpreadSecurity<128> FixedSpreadSecurityL;
typedef FixedSpreadSecurity<512> FixedSpreadSecurityXL;
std::string security_descriptor(const api::Security&);
// Convert a fixedsecurity to a normal Security - caveat: spreads will be normalized
Security convert_security(const FixedSecurity&);
void convert_security(const FixedSecurity&, Security*);
void convert_security(const Security& src, FixedSecurity& dest, bool set_security_key=false);
SecurityType securitytype_of_contractcase(Security::ContractCase cc);
SecurityType securitytype_of(const Security&);
size_t num_legs(const Security&);
uint64_t exchange_id(const Security& security);
// Stack allocates a security of the given type
template <class C>
void with_security(SecurityType type, size_t leg_count, const api::Security* psynthetic, C cb) {
switch(type) {
case api::SECURITYTYPE_STOCK: {
FixedStockSecurity security;
cb(security);
return;
}
case api::SECURITYTYPE_FUTURE: {
FixedFutureSecurity security;
bts_assert(security.type == type);
cb(security);
return;
}
case api::SECURITYTYPE_OPTION: {
FixedOptionSecurity security;
bts_assert(security.type == type);
cb(security);
return;
}
case api::SECURITYTYPE_SPREAD: {
if (leg_count <= 4) {
FixedSpreadSecurity<4> security;
cb(security);
}
else if (leg_count <= FixedSpreadSecurityS::static_count()) {
FixedSpreadSecurityS security;
cb(security);
}
else if (leg_count <= FixedSpreadSecurityL::static_count()) {
FixedSpreadSecurityL security;
cb(security);
}
else if (leg_count <= FixedSpreadSecurityXL::static_count()) {
FixedSpreadSecurityXL security;
cb(security);
}
else {
std::stringstream msg("Too many legs (");
msg << leg_count;
msg << ")";
bts_assert_msg(false, msg.str());
}
return;
}
case api::SECURITYTYPE_SYNTHETIC: {
bts_assert(psynthetic);
// Use a vector to allocate the right size
// Then use the FixedSynthetic constructor to serialize the api::Security into those bytes
// We could optimize this by using a fixed size stack buffer and only heap allocating if we exceed that
// but in general FixedSynthetic is not performance sensitive
std::vector<uint8_t> buffer;
buffer.resize(psynthetic->ByteSize() + sizeof(FixedSyntheticSecurity));
auto* psec = new (&buffer[0]) FixedSyntheticSecurity(*psynthetic);
cb(*psec);
return;
}
case api::SECURITYTYPE_UNSET:
case api::SecurityType_INT_MAX_SENTINEL_DO_NOT_USE_:
case api::SecurityType_INT_MIN_SENTINEL_DO_NOT_USE_:
break;
}
bts_assert(false);
}
template <class C>
void with_security_like(const api::Security& security, C cb) {
return with_security(securitytype_of(security), num_legs(security), &security, cb);
}
}}//namespace