bomex.git - Gitblit

			@@ -28,29 +28,29 @@

			void initialise()
			{
			mapTypes = {{"FUTURE", FUTURE_TYPE},
			{"SPREAD", SPREAD_TYPE},
			{"CALL", CALL_TYPE},
			{"PUT", PUT_TYPE},
			{"SETTLEMENT", SETTLEMENT},
			{"ADDED", ADDED},
			{"DELETED", DELETED},
			{"TRADE", TRADE},
			{"BROKER_REQUEST", BROKER_REQUEST},
			{"BROKER_ACK", BROKER_ACK},
			{"BROKER_CONFIRM", BROKER_CONFIRM}};
			mapTypes = {{"FUTURE", FUTURE_TYPE},
			{"SPREAD", SPREAD_TYPE},
			{"CALL", CALL_TYPE},
			{"PUT", PUT_TYPE},
			{"SETTLEMENT", SETTLEMENT},
			{"ADDED", ADDED},
			{"DELETED", DELETED},
			{"TRADE", TRADE},
			{"BROKER_REQUEST", BROKER_REQUEST},
			{"BROKER_ACK", BROKER_ACK},
			{"BROKER_CONFIRM", BROKER_CONFIRM}};

			mapAnnounce = {{FUTURE_TYPE, book::FUTURE},
			{SPREAD_TYPE, book::SPREAD},
			{CALL_TYPE, book::CALL},
			{PUT_TYPE, book::PUT}};
			mapAnnounce = {{FUTURE_TYPE, book::FUTURE},
			{SPREAD_TYPE, book::SPREAD},
			{CALL_TYPE, book::CALL},
			{PUT_TYPE, book::PUT}};

			mapOrder = {{"BUY", book::Buy}, {"SELL", book::Sell}};
			mapOrder = {{"BUY", book::Buy}, {"SELL", book::Sell}};

			mapTrade = {{"BUY_AGGRESSOR", BUY_AGGRESSOR},
			{"SELL_AGGRESSOR", SELL_AGGRESSOR}};
			mapTrade = {{"BUY_AGGRESSOR", BUY_AGGRESSOR},
			{"SELL_AGGRESSOR", SELL_AGGRESSOR}};

			mapOrderSide = {{book::Buy, "BUY"}, {book::Sell, "SELL"}};
			mapOrderSide = {{book::Buy, "BUY"}, {book::Sell, "SELL"}};
			}

			Message* parseSingle(rapidjson::Value& d);
			@@ -65,159 +65,159 @@

			std::queue<Message*> parse(std::string& str)
			{
			std::queue<Message*> out;
			rapidjson::Document d;
			d.Parse(str.c_str());
			if (d.IsArray()) {
			for (rapidjson::SizeType i = 0; i < d.Size(); i++) {
			out.push(parseSingle(d[i]));
			std::queue<Message*> out;
			rapidjson::Document d;
			d.Parse(str.c_str());
			if (d.IsArray()) {
			for (rapidjson::SizeType i = 0; i < d.Size(); i++) {
			out.push(parseSingle(d[i]));
			}
			} else {
			out.push(parseSingle(d));
			}
			} else {
			out.push(parseSingle(d));
			}
			return out;
			return out;
			}

			Message* parseSingle(rapidjson::Value& d)
			{
			if (mapTypes.empty()) {
			initialise();
			}
			Message* out;
			switch (mapTypes[d["type"].GetString()]) {
			case FUTURE_TYPE:
			case SPREAD_TYPE:
			case CALL_TYPE:
			case PUT_TYPE:
			out = announce(d);
			break;
			case SETTLEMENT:
			out = settle(d);
			break;
			case ADDED:
			out = added(d);
			break;
			case DELETED:
			out = deleted(d);
			break;
			case TRADE:
			out = trade(d);
			break;
			case BROKER_REQUEST:
			out = brokerReq(d);
			break;
			case BROKER_ACK:
			out = brokerAck(d);
			break;
			case BROKER_CONFIRM:
			out = brokerCon(d);
			break;
			default:
			out = new Message(NONE, "");
			break;
			}
			return out;
			if (mapTypes.empty()) {
			initialise();
			}
			Message* out;
			switch (mapTypes[d["type"].GetString()]) {
			case FUTURE_TYPE:
			case SPREAD_TYPE:
			case CALL_TYPE:
			case PUT_TYPE:
			out = announce(d);
			break;
			case SETTLEMENT:
			out = settle(d);
			break;
			case ADDED:
			out = added(d);
			break;
			case DELETED:
			out = deleted(d);
			break;
			case TRADE:
			out = trade(d);
			break;
			case BROKER_REQUEST:
			out = brokerReq(d);
			break;
			case BROKER_ACK:
			out = brokerAck(d);
			break;
			case BROKER_CONFIRM:
			out = brokerCon(d);
			break;
			default:
			out = new Message(NONE, "");
			break;
			}
			return out;
			}

			AnnounceMessage* announce(rapidjson::Value& d)
			{
			// std::stringstream expiryStream(d["expiry"].GetString());
			std::chrono::nanoseconds exp_time(0);
			// expiryStream >>
			// date::parse("%Y-%m-%f %H:%M%z", exp_time); // Parsing is broken
			return new AnnounceMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["stationId"].GetInt(), d["stationName"].GetString(),
			d["unit"].GetString(), exp_time, d["aggressiveFee"].GetDouble(),
			d["passiveFee"].GetDouble(), d["brokerFee"].GetDouble(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			// std::stringstream expiryStream(d["expiry"].GetString());
			std::chrono::nanoseconds exp_time(0);
			// expiryStream >>
			// date::parse("%Y-%m-%f %H:%M%z", exp_time); // Parsing is broken
			return new AnnounceMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["stationId"].GetInt(), d["stationName"].GetString(),
			d["unit"].GetString(), exp_time, d["aggressiveFee"].GetDouble(),
			d["passiveFee"].GetDouble(), d["brokerFee"].GetDouble(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			}

			SettleMessage* settle(rapidjson::Value& d)
			{
			// std::stringstream expiryStream(d["expiry"].GetString());
			std::chrono::nanoseconds exp_time(0);
			// expiryStream >> date::parse("%Y-%m-%d %H:%M%z", exp_time);
			return new SettleMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["stationName"].GetString(), exp_time, d["price"].GetDouble(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			// std::stringstream expiryStream(d["expiry"].GetString());
			std::chrono::nanoseconds exp_time(0);
			// expiryStream >> date::parse("%Y-%m-%d %H:%M%z", exp_time);
			return new SettleMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["stationName"].GetString(), exp_time, d["price"].GetDouble(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			}

			AddedMessage* added(rapidjson::Value& d)
			{
			return new AddedMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["id"].GetString(), mapOrder[d["side"].GetString()],
			d["price"].GetDouble(), d["filled"].GetInt(), d["resting"].GetInt(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			return new AddedMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["id"].GetString(), mapOrder[d["side"].GetString()],
			d["price"].GetDouble(), d["filled"].GetInt(), d["resting"].GetInt(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			}

			DeletedMessage* deleted(rapidjson::Value& d)
			{
			return new DeletedMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["id"].GetString(), mapOrder[d["side"].GetString()],
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			return new DeletedMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["id"].GetString(), mapOrder[d["side"].GetString()],
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			}

			TradeMessage* trade(rapidjson::Value& d)
			{
			return new TradeMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), d["volume"].GetInt(), d["buyer"].GetString(),
			d["seller"].GetString(), mapTrade[d["tradeType"].GetString()],
			d["passiveOrder"].GetString(), d["passiveOrderRemaining"].GetInt(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			return new TradeMessage(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), d["volume"].GetInt(), d["buyer"].GetString(),
			d["seller"].GetString(), mapTrade[d["tradeType"].GetString()],
			d["passiveOrder"].GetString(), d["passiveOrderRemaining"].GetInt(),
			d["sequence"].GetInt(), d["timestamp"].GetDouble());
			}

			BrokerRequest* brokerReq(rapidjson::Value& d)
			{
			return new BrokerRequest(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), mapOrder[d["side"].GetString()],
			d["volume"].GetInt(), d["counterparty"].GetString());
			return new BrokerRequest(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), mapOrder[d["side"].GetString()],
			d["volume"].GetInt(), d["counterparty"].GetString());
			}

			BrokerAck* brokerAck(rapidjson::Value& d)
			{
			return new BrokerAck(mapTypes[d["type"].GetString()],
			d["product"].GetString(), d["price"].GetDouble(),
			mapOrder[d["side"].GetString()], d["volume"].GetInt(),
			d["counterparty"].GetString(), d["id"].GetString(),
			d["brokerTradeStatus"].GetString(),
			d["owner"].GetString());
			return new BrokerAck(mapTypes[d["type"].GetString()],
			d["product"].GetString(), d["price"].GetDouble(),
			mapOrder[d["side"].GetString()], d["volume"].GetInt(),
			d["counterparty"].GetString(), d["id"].GetString(),
			d["brokerTradeStatus"].GetString(),
			d["owner"].GetString());
			}
			BrokerConfirm* brokerCon(rapidjson::Value& d)
			{
			return new BrokerConfirm(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), mapOrder[d["side"].GetString()],
			d["volume"].GetInt(), d["counterparty"].GetString(),
			d["id"].GetString());
			return new BrokerConfirm(
			mapTypes[d["type"].GetString()], d["product"].GetString(),
			d["price"].GetDouble(), mapOrder[d["side"].GetString()],
			d["volume"].GetInt(), d["counterparty"].GetString(),
			d["id"].GetString());
			}

			Message::Message() : type(NONE), product("error") {}

			Message::Message(MessageTypes types, std::string product)
			: type(types), product(product)
			: type(types), product(product)
			{
			}

			FromExchange::FromExchange(MessageTypes type, std::string product,
			uint64_t sequence, double timestamp)
			: Message(type, product), sequence(sequence), timestamp(timestamp)
			: Message(type, product), sequence(sequence), timestamp(timestamp)
			{
			}

			ToExchange::ToExchange(MessageTypes type, std::string product)
			: Message(type, product){};
			: Message(type, product){};

			Broker::Broker(MessageTypes type, std::string product, double price,
			book::OrderSideEnum side, uint64_t volume,
			std::string counterparty)
			: Message(type, product), price(price), side(side), volume(volume),
			counterparty(counterparty)
			: Message(type, product), price(price), side(side), volume(volume),
			counterparty(counterparty)
			{
			}

			@@ -227,9 +227,9 @@
			std::chrono::nanoseconds expiry, double aggFee,
			double pasFee, double broFee,
			uint64_t sequence, double timestamp)
			: FromExchange(type, product, sequence, timestamp), stationId(stationId),
			stationName(stationName), unit(unit), expiry(expiry), aggFee(aggFee),
			pasFee(pasFee), broFee(broFee)
			: FromExchange(type, product, sequence, timestamp), stationId(stationId),
			stationName(stationName), unit(unit), expiry(expiry), aggFee(aggFee),
			pasFee(pasFee), broFee(broFee)
			{
			}

			@@ -237,59 +237,59 @@
			std::string stationName,
			std::chrono::nanoseconds expiry, double price,
			uint64_t sequence, double timestamp)
			: FromExchange(type, product, sequence, timestamp),
			stationName(stationName), expiry(expiry), price(price)
			: FromExchange(type, product, sequence, timestamp),
			stationName(stationName), expiry(expiry), price(price)
			{
			}

			AddMessage::AddMessage(MessageTypes type, std::string product, double price,
			book::OrderSideEnum side, uint64_t volume)
			: ToExchange(type, product), price(price), side(side), volume(volume)
			: ToExchange(type, product), price(price), side(side), volume(volume)
			{
			}

			std::string AddMessage::as_string()
			{
			if (mapOrderSide.empty()) initialise();
			return "{\"type\": \"ADD\", \"product\": \"" + this->product +
			"\", \"price\": " + std::to_string(this->price) + ", \"side\": \"" +
			mapOrderSide[this->side] +
			"\", \"volume\": " + std::to_string(this->volume) + "}";
			if (mapOrderSide.empty()) initialise();
			return "{\"type\": \"ADD\", \"product\": \"" + this->product +
			"\", \"price\": " + std::to_string(this->price) + ", \"side\": \"" +
			mapOrderSide[this->side] +
			"\", \"volume\": " + std::to_string(this->volume) + "}";
			}

			AddedMessage::AddedMessage(MessageTypes type, std::string product,
			std::string id, book::OrderSideEnum side,
			double price, uint64_t filled, uint64_t resting,
			uint64_t sequence, double timestamp)
			: FromExchange(type, product, sequence, timestamp), id(id), side(side),
			price(price), filled(filled), resting(resting)
			: FromExchange(type, product, sequence, timestamp), id(id), side(side),
			price(price), filled(filled), resting(resting)
			{
			}

			DeleteMessage::DeleteMessage(MessageTypes type, std::string product,
			std::string id)
			: ToExchange(type, product), id(id)
			: ToExchange(type, product), id(id)
			{
			}

			std::string DeleteMessage::as_string()
			{
			if (mapOrderSide.empty()) initialise();
			return "{\"type\": \"DELETE\", \"product\": \"" + this->product +
			"\", \"id\": \"" + this->id + "\"}";
			if (mapOrderSide.empty()) initialise();
			return "{\"type\": \"DELETE\", \"product\": \"" + this->product +
			"\", \"id\": \"" + this->id + "\"}";
			}

			DeletedMessage::DeletedMessage(MessageTypes type, std::string product,
			std::string id, book::OrderSideEnum side,
			uint64_t sequence, double timestamp)
			: FromExchange(type, product, sequence, timestamp), id(id), side(side)
			: FromExchange(type, product, sequence, timestamp), id(id), side(side)
			{
			}

			RejectMessage::RejectMessage(MessageTypes type, std::string product,
			std::string error, uint64_t sequence,
			double timestamp)
			: FromExchange(type, product, sequence, timestamp), error(error)
			: FromExchange(type, product, sequence, timestamp), error(error)
			{
			}

			@@ -299,16 +299,16 @@
			std::string passiveOrder,
			uint64_t passiveOrderRemaining, uint64_t sequence,
			double timestamp)
			: FromExchange(type, product, sequence, timestamp), price(price),
			volume(volume), buyer(buyer), seller(seller), tradeType(tradeType),
			passiveOrder(passiveOrder), passiveOrderRemaining(passiveOrderRemaining)
			: FromExchange(type, product, sequence, timestamp), price(price),
			volume(volume), buyer(buyer), seller(seller), tradeType(tradeType),
			passiveOrder(passiveOrder), passiveOrderRemaining(passiveOrderRemaining)
			{
			}

			BrokerRequest::BrokerRequest(MessageTypes type, std::string product,
			double price, book::OrderSideEnum side,
			uint64_t volume, std::string counterparty)
			: Broker(type, product, price, side, volume, counterparty)
			: Broker(type, product, price, side, volume, counterparty)
			{
			}

			@@ -316,8 +316,8 @@
			book::OrderSideEnum side, uint64_t volume,
			std::string counterparty, std::string id,
			std::string brokerTradeStatus, std::string owner)
			: Broker(type, product, price, side, volume, counterparty), id(id),
			brokerTradeStatus(brokerTradeStatus), owner(owner)
			: Broker(type, product, price, side, volume, counterparty), id(id),
			brokerTradeStatus(brokerTradeStatus), owner(owner)
			{
			}

			@@ -325,7 +325,7 @@
			double price, book::OrderSideEnum side,
			uint64_t volume, std::string counterparty,
			std::string id)
			: Broker(type, product, price, side, volume, counterparty), id(id)
			: Broker(type, product, price, side, volume, counterparty), id(id)
			{
			}
			} // namespace json