Pull data from ftp and parse

Joel Grunbaum

2022-01-12 611ad7b12fcc6b34229316099ae66bccbcf24ad9

 book.cpp

@@ -1,127 +1,150 @@
#include "book.hpp"
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <iostream>
#include <string>

Order::Order(double price, OrderSideEnum side, int volume,
             std::chrono::nanoseconds timestamp, std::string id)
    : price{price}, side{side}, remaining_volume{volume},
      filled_volume(0), timestamp{timestamp}, id{id} {}

Level::Level(Order &order)
    : price{order.price}, volume(order.remaining_volume), side{order.side},
      timestamp{order.timestamp}, id{order.id} {}

bool operator<(const Level &a, const Level &b) {
  if (a.price < b.price)
    return true;
  else if (a.price == b.price && a.timestamp < b.timestamp)
    return true;
  else
    return false;
namespace book
{
Order::Order(double price, OrderSideEnum side, int volume, double timestamp,
             std::string id)
   : price{price}, side{side}, remaining_volume{volume},
     filled_volume(0), timestamp{timestamp}, id{id}
{
}

bool operator>(const Level &a, const Level &b) {
  if (a.price > b.price)
    return true;
  else if (a.price == b.price && a.timestamp > b.timestamp)
    return true;
  else
    return false;
Level::Level(Order& order)
   : price{order.price}, volume(order.remaining_volume), side{order.side},
     timestamp{order.timestamp}, id{order.id}
{
}

bool operator<=(const Level &a, const Level &b) {
  if (a.price <= b.price)
    return true;
  else if (a.price == b.price && a.timestamp <= b.timestamp)
    return true;
  else
    return false;
bool operator<(const Level& a, const Level& b)
{
   if (a.price < b.price)
      return true;
   else if (a.price == b.price && (a.timestamp > b.timestamp))
      return true;
   else
      return false;
}

bool operator>=(const Level &a, const Level &b) {
  if (a.price >= b.price)
    return true;
  else if (a.price == b.price && a.timestamp >= b.timestamp)
    return true;
  else
    return false;
bool operator>(const Level& a, const Level& b)
{
   if (a.price > b.price)
      return true;
   else if (a.price == b.price && (a.timestamp > b.timestamp))
      return true;
   else
      return false;
}

bool operator==(const Level &a, const Level &b) {
  if (a.price == b.price && a.timestamp == b.timestamp)
    return true;
  else
    return false;
bool operator<=(const Level& a, const Level& b)
{
   if (a.price <= b.price)
      return true;
   else if (a.price == b.price && (a.timestamp >= b.timestamp))
      return true;
   else
      return false;
}

bool operator>=(const Level& a, const Level& b)
{
   if (a.price >= b.price)
      return true;
   else if (a.price == b.price && (a.timestamp >= b.timestamp))
      return true;
   else
      return false;
}

bool operator==(const Level& a, const Level& b)
{
   if (a.price == b.price && (a.timestamp == b.timestamp))
      return true;
   else
      return false;
}

std::ostream& operator<<(std::ostream& out, const Level& a)
{
   return out << "Price: " << a.price << ", volume: " << a.volume
              << ", time: " << a.timestamp << ", id: " << a.id;
}

Book::Book()
    : bidSide(), askSide(), productType(TEST), product("a"), stationId("b"),
      unit("c"), expiry(std::chrono::nanoseconds(0)), aggFee(1), pasFee(-1),
      broFee(2) {}

Book::Book(ProductTypeEnum productType, std::string product,
           std::string stationId, std::string unit,
           std::chrono::nanoseconds expiry, double aggFee, double pasFee,
           double broFee)
    : bidSide{}, askSide{}, productType{productType}, product(product),
      stationId(stationId), unit(unit), expiry(expiry), aggFee(aggFee),
      pasFee(pasFee), broFee(broFee) {}

void Book::ask(Order &order) {
  while (this->bidSide.size() && this->bidSide.top().price > order.price) {
    if (this->bidSide.top().volume > order.remaining_volume) {
      int temp = this->bidSide.top().volume;
      order.filled_volume += temp;
      this->bidSide.topRemoveVolume(order.remaining_volume);
      order.remaining_volume -= temp;
    } else {
      order.remaining_volume -= this->bidSide.top().volume;
      order.filled_volume += this->bidSide.top().volume;
      this->bidSide.pop();
    }
    if (order.remaining_volume > 0) {
      this->askSide.emplace(order);
    }
  }
   : bidSide(), askSide(), productType(TEST), product("a"), stationId(7),
     unit("c"), expiry(std::chrono::nanoseconds(0)), aggFee(1), pasFee(-1),
     broFee(2)
{
}

void Book::bid(Order &order) {
  while (this->askSide.size() && this->askSide.top().price > order.price) {
    if (this->askSide.top().volume > order.remaining_volume) {
      int temp = this->askSide.top().volume;
      order.filled_volume += temp;
      this->askSide.topRemoveVolume(order.remaining_volume);
      order.remaining_volume -= temp;
    } else {
      order.remaining_volume -= this->askSide.top().volume;
      order.filled_volume += this->askSide.top().volume;
      this->askSide.pop();
    }
    if (order.remaining_volume > 0) {
      this->bidSide.emplace(order);
    }
  }
Book::Book(ProductTypeEnum productType, std::string product, int stationId,
           std::string unit, std::chrono::nanoseconds expiry, double aggFee,
           double pasFee, double broFee)
   : bidSide{}, askSide{}, productType{productType}, product(product),
     stationId(stationId), unit(unit), expiry(expiry), aggFee(aggFee),
     pasFee(pasFee), broFee(broFee), bomPrice(0)
{
}

void Book::printBook() {
  std::cout << "Sell side";
  this->askSide.printTop();
  std::cout << "Buy side";
  this->bidSide.printTop();
void Book::ask(Order& order)
{
    auto a = 
    this->askSide.emplace(order.id, order);
    if (!a.second) {
        std::cout << order.id << "already exists" << std::endl;
    }
}

Book testBook(int orders, bool printBook) {
  Book b = Book();
  std::chrono::nanoseconds time(1);
  for (int i = 0; i < orders; i++) {
    Order t(i, Buy, 10, time++, "a");
    b.bid(t);
  }
  for (int i = orders + 1; i < 2 * orders; i++) {
    Order t(i, Sell, 10, time++, "b");
    b.ask(t);
  }
  if (printBook)
    b.printBook();
  return b;
void Book::bid(Order& order)
{
    auto a =
    this->bidSide.emplace(order.id, order);
    if (!a.second) {
        std::cout << order.id << "already exists" << std::endl;
    }
}

void Book::printBook(std::size_t numOrders)
{
   std::cout << "Sell side: " << this->askSide.size() << std::endl;
   std::vector<Level> askCopy;
    for (auto i : this->askSide) askCopy.push_back(i.second);
   std::size_t count = 0;
   std::sort(askCopy.begin(), askCopy.end());
   for (auto i = askCopy.rbegin(); i != askCopy.rend(); i++) {
      std::cout << *i << std::endl;
      count++;
      if (count > numOrders) break;
   }
   std::cout << "Buy side: " << this->bidSide.size() << std::endl;
   std::vector<Level> bidCopy;
    for (auto i : this->bidSide) bidCopy.push_back(i.second);
   count = 0;
   std::sort(bidCopy.begin(), bidCopy.end());
   for (auto i = bidCopy.rbegin(); i != bidCopy.rend(); i++) {
      std::cout << *i << std::endl;
      count++;
      if (count > numOrders) break;
   }
}

Book testBook(int orders, bool printBook)
{
   Book b = Book();
   double time(1);
   for (int i = 1; i < orders; i++) {
      Order t(i, Buy, 10, time++, std::to_string(i));
      b.bid(t);
   }
   for (int i = orders + 1; i < 2 * orders; i++) {
      Order t(i, Sell, 10, time++, std::to_string(i));
      b.ask(t);
   }
   if (printBook) b.printBook(orders - 1);
   return b;
}
} // namespace book