Added Order and OrderList ADT with corresponding tests

Author: jmsadair

.gitignore

@@ -0,0 +1,5 @@
+# Ignore CMake Debug and Release builds
+cmake-build-release
+cmake-build-debug
+# Ignore .idea folder generated by CLion
+.idea

CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.5)
+project(fast_exchange)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -O3")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/bin")
+set(CMAKE_INSTALL_PREFIX ${PROJECT_SOURCE_DIR})
+set(EXCHANGE_INSTALL_LIB_DIR ${PROJECT_SOURCE_DIR}/lib)
+set(EXCHANGE_INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR})
+add_subdirectory(src)
+enable_testing()
+add_subdirectory(test)

bin/.gitignore

@@ -0,0 +1,3 @@
+*
+*/
+!.gitignore

src/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.5)
+project(fast_exchange_source)
+add_subdirectory(order_book)

src/order_book/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.5)
+project(order_book)
+find_package(Boost)
+if(Boost_FOUND)
+    add_library(${PROJECT_NAME} src/order_list.cpp)
+    target_include_directories(${PROJECT_NAME} PUBLIC include ${Boost_INCLUDE_DIRS})
+endif()

src/order_book/include/order.h

@@ -0,0 +1,125 @@
+#ifndef FAST_EXCHANGE_ORDER_H
+#define FAST_EXCHANGE_ORDER_H
+#include <chrono>
+#include <string>
+#include <utility>
+#include <array>
+#include <stdexcept>
+#include <numeric>
+#include <cmath>
+#include <iomanip>
+#include <boost/intrusive/list.hpp>
+
+// Represents the different actions of orders.
+enum class OrderAction {Limit = 0, Market = 1};
+constexpr std::array order_action_to_string {"LIMIT", "MARKET"};
+
+//Represents the different types of orders.
+// Good 'Til Cancelled: A good-til-canceled order will remain active until
+//                      you decide to cancel it.
+// Fill Or Kill: A fill-or-kill order will be executed immediately in its entirety;
+//             otherwise, it will be cancelled.
+// Immediate or Cancel: A immediate-or-cancel order will be executed immediately
+//                      as fully as possible. Non-executed parts of the order are deleted
+//                      without entry in the order book.
+enum class OrderType {GoodTillCancel = 0, FillOrKill = 1, ImmediateOrCancel = 2};
+constexpr std::array order_type_to_string {"GTC", "FOK", "IOC"};
+
+// Represents the side of the order.
+enum class OrderSide {Bid = 0, Ask = 1};
+constexpr std::array order_side_to_string {"BID", "ASK"};
+
+// Represents the status of an order.
+enum class OrderStatus {Accepted = 0, Rejected = 1, PartiallyFilled = 1, Filled = 2, Cancelled = 3};
+constexpr std::array order_status_to_string {"ACCEPTED", "REJECTED", "PARTIALLY FILLED", "FILLED", "CANCELLED"};
+
+using namespace boost::intrusive;
+
+/**
+ * An mutable order ADT.
+ */
+struct Order: public list_base_hook<> {
+    const OrderAction action;
+    const OrderSide side;
+    const OrderType type;
+    const uint64_t user_id;
+    const uint64_t id;
+    const std::string symbol;
+    const std::chrono::time_point<std::chrono::system_clock> time;
+    const float price;
+    OrderStatus status;
+    uint64_t quantity;
+
+    /**
+     * A constructor for the order ADT.
+     * TODO: When is an order rejected?
+     *
+     * @param order_action the action of the order - limit or market.
+     * @param order_side the side of the order - ask or bid.
+     * @param order_type the type of the order - GTC, IOC, FOK.
+     * @param order_quantity the quantity of the order, require that quantity is positive.
+     * @param order_price the price of the order, require that price is non-negative.
+     * @param order_id a unique ID associated with the order.
+     * @param order_user_id a unique ID associated with the user placing the order.
+     * @throws Error if price is negative or if quantity is not positive.
+     */
+    Order(OrderAction order_action, OrderSide order_side, OrderType order_type, uint64_t order_quantity, float order_price,
+          uint64_t order_id, uint64_t order_user_id)
+    : action(order_action), side(order_side), type(order_type), status(OrderStatus::Accepted), quantity(order_quantity),
+      price(order_price), id(order_id), user_id(order_user_id), time(std::chrono::system_clock::now())
+    {
+        if (quantity == 0)
+            throw std::invalid_argument("quantity must be positive!");
+        if (price < 0)
+            throw std::invalid_argument("price must be non-negative!");
+    }
+
+    /**
+     * Indicates whether two orders are equal. Two orders are equal if and only if they have
+     * the same status, the same side, the same ID, and the same price (within epsilon).
+     *
+     * @param other another order.
+     * @return true if the orders are equal and false otherwise.
+     */
+    bool operator==(const Order& other) const {
+        return status == other.status &&
+               action == other.action &&
+               type == other.type &&
+               side == other.side &&
+               id == other.id &&
+               user_id == other.user_id &&
+               quantity == other.quantity &&
+               (std::fabs(price - other.price) <=
+                std::numeric_limits<float>::epsilon() * std::fmax(std::fabs(price), std::fabs(other.price)));
+    }
+
+    bool operator!=(const Order& other) const {
+        return !(*this == other);
+    }
+    /**
+     * @return the string representation of an order.
+     */
+    std::string toString() {
+        auto order_time = std::chrono::system_clock::to_time_t(time);
+        std::string time_string = std::ctime(&order_time);
+        std::string order_action = order_action_to_string[static_cast<std::underlying_type<OrderStatus>::type>(action)];
+        std::string order_side = order_side_to_string[static_cast<std::underlying_type<OrderStatus>::type>(side)];
+        std::string order_status = order_status_to_string[static_cast<std::underlying_type<OrderStatus>::type>(status)];
+        std::string order_type = order_type_to_string[static_cast<std::underlying_type<OrderStatus>::type>(type)];
+        std::string order_price = std::to_string(price);
+        std::string order_quantity = std::to_string(quantity);
+        std::string order_id = std::to_string(id);
+        std::string order_user_id = std::to_string(user_id);
+
+        return "Order ID: " + order_id +
+                "\nUser ID: " + order_user_id +
+                "\nOrder Time: " + time_string +
+                "\nOrder Side: " + order_side +
+                "\nOrder Action: " + order_action +
+                "\nOrder Status: " + order_status +
+                "\nOrder Type: " + order_type +
+                "\nOrder Price: " + order_price +
+                "\nOrder Quantity: " + order_quantity + "\n";
+    }
+};
+#endif //FAST_EXCHANGE_ORDER_H

src/order_book/include/order_list.h

@@ -0,0 +1,77 @@
+#ifndef FAST_EXCHANGE_ORDER_LIST_H
+#define FAST_EXCHANGE_ORDER_LIST_H
+#include <list>
+#include <unordered_map>
+#include "order.h"
+
+using namespace boost::intrusive;
+
+/**
+ * A doubly linked list of orders that are associated with a single price.
+ */
+class OrderList {
+public:
+    /**
+     * A constructor for the OrderList ADT, initializes
+     * an empty OrderList.
+     */
+    OrderList() = default;
+
+    /**
+     * A constructor for the OrderList ADT, initializes
+     * an order list with a single order.
+     *
+     * @param order an order.
+     */
+    explicit OrderList(Order& order);
+
+    /**
+     * Adds an order to the front of the order list if it is not
+     * already in the list and it has the same price level.
+     *
+     * @param order an order, require that price associated with
+     *              the order is equal to the price of the order
+     *              list.
+     * @throws Error if the order does not have the same price as
+     *               the order list.
+     */
+    void addOrder(Order& order);
+
+    /**
+     * Removes the order associated with order_id
+     * from the list - does not cancel the order.
+     *
+     * @param order_id the ID of the order to remove, require
+     *                  that the order associated with ID
+     *                  is in the order list.
+     * @return the order that was removed from the list.
+     * @throws Error if the order associated with order_id
+     *               is not in the order list.
+     */
+    void removeOrder(const Order& order);
+
+    /**
+     * Given an order ID, determines whether the order associated with that ID
+     * is in the order list.
+     *
+     * @param order_id an ID associated with an order.
+     * @return true if the order associated with order_id is in the order list
+     *         and false otherwise.
+     */
+    bool hasOrder(const Order& order);
+
+    /**
+     * @returns true if the order list is empty and false otherwise.
+     */
+    bool isEmpty();
+
+    /**
+     * @returns the number of orders that are in the order list.
+     */
+    size_t size();
+
+private:
+    // A doubly-linked list of orders.
+    list<Order> order_list;
+};
+#endif //FAST_EXCHANGE_ORDER_LIST_H

src/order_book/src/order_list.cpp

@@ -0,0 +1,28 @@
+#include <algorithm>
+#include "order_list.h"
+
+OrderList::OrderList(Order& order) {
+    order_list.push_back(order);
+}
+
+void OrderList::addOrder(Order& order) {
+    order_list.push_back(order);
+}
+
+void OrderList::removeOrder(const Order &order) {
+    auto order_it = order_list.iterator_to(order);
+    // Require that order is in list.
+    assert(order_it != order_list.end());
+    order_list.erase(order_it);
+}
+bool OrderList::isEmpty() {
+    return order_list.empty();
+}
+
+size_t OrderList::size() {
+    return order_list.size();
+}
+
+bool OrderList::hasOrder(const Order& order) {
+    return std::find(order_list.begin(), order_list.end(), order) != order_list.end();
+}

test/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.8)
+project(fast_exchange_tests)
+find_package(GTest REQUIRED)
+add_executable(fast_exchange_tests order_test.cpp order_list_test.cpp)
+target_link_libraries(fast_exchange_tests GTest::GTest GTest::Main order_book)
+install(TARGETS fast_exchange_tests DESTINATION ${EXCHANGE_INSTALL_BIN_DIR})
+include(GoogleTest)
+gtest_discover_tests(fast_exchange_tests)

test/order_list_test.cpp

@@ -0,0 +1,73 @@
+#include <gtest/gtest.h>
+#include "order_list.h"
+
+TEST(OrderListTest, HandlesAddAndRemoveOrder) {
+    const auto order1_action = OrderAction::Limit;
+    const auto order1_side = OrderSide::Bid;
+    const auto order1_type = OrderType::GoodTillCancel;
+    const auto order1_quantity = 301;
+    const auto order1_price = 69.54;
+    const auto order1_id = 1;
+    const auto order1_user_id = 1;
+    const auto order2_action = OrderAction::Limit;
+    const auto order2_side = OrderSide::Bid;
+    const auto order2_type = OrderType::GoodTillCancel;
+    const auto order2_quantity = 245;
+    const auto order2_price = 69.54;
+    const auto order2_id = 2;
+    const auto order2_user_id = 2;
+    const auto order3_action = OrderAction::Limit;
+    const auto order3_side = OrderSide::Bid;
+    const auto order3_type = OrderType::GoodTillCancel;
+    const auto order3_quantity = 657;
+    const auto order3_price = 220.32;
+    const auto order3_id = 3;
+    const auto order3_user_id = 3;
+    const auto expected_size1 = 1;
+    const auto expected_size2 = 2;
+    const auto expected_size3 = 3;
+    const auto expected_size4 = 0;
+    auto order1 = Order(order1_action, order1_side, order1_type, order1_quantity,
+                        order1_price, order1_id, order1_user_id);
+    auto order2 = Order(order2_action, order2_side, order2_type, order2_quantity,
+                        order2_price, order2_id, order2_user_id);
+    auto order3 = Order(order3_action, order3_side, order3_type, order3_quantity,
+                        order3_price, order3_id, order3_user_id);
+    OrderList order_list;
+
+    // Add the orders to the list.
+    order_list.addOrder(order1);
+    ASSERT_TRUE(order_list.size() == expected_size1);
+    ASSERT_TRUE(order_list.hasOrder(order1));
+    order_list.addOrder(order2);
+    ASSERT_TRUE(order_list.size() == expected_size2);
+    ASSERT_TRUE(order_list.hasOrder(order2));
+    order_list.addOrder(order3);
+    ASSERT_TRUE(order_list.size() == expected_size3);
+    ASSERT_TRUE(order_list.hasOrder(order3));
+    // Remove orders from the list.
+    order_list.removeOrder(order1);
+    ASSERT_TRUE(order_list.size() == expected_size2);
+    ASSERT_TRUE(!order_list.hasOrder(order1));
+    order_list.removeOrder(order2);
+    ASSERT_TRUE(order_list.size() == expected_size1);
+    ASSERT_TRUE(!order_list.hasOrder(order2));
+    order_list.removeOrder(order3);
+    ASSERT_TRUE(order_list.size() == expected_size4);
+    ASSERT_TRUE(!order_list.hasOrder(order3));
+}
+
+TEST(OrderListTest, HandlesIsEmptyCorrectly) {
+    const auto order_action = OrderAction::Limit;
+    const auto order_side = OrderSide::Bid;
+    const auto order_type = OrderType::GoodTillCancel;
+    const auto order_quantity = 301;
+    const auto order_price = 69.54;
+    const auto order_id = 1;
+    const auto order_user_id = 1;
+    auto order = Order(order_action, order_side, order_type, order_quantity, order_price, order_id, order_user_id);
+    auto order_list = OrderList(order);
+    ASSERT_TRUE(!order_list.isEmpty());
+    order_list.removeOrder(order);
+    ASSERT_TRUE(order_list.isEmpty());
+}