structures.hpp

// Types and structures for the LimitOrderBook: order, limit, account
// Copyright 2020 Christian Kauten
//
// Author: Christian Kauten (kautenja@auburn.edu)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#ifndef ORDER_ENTRY_LIMIT_ORDER_BOOK_STRUCTURES_HPP
#define ORDER_ENTRY_LIMIT_ORDER_BOOK_STRUCTURES_HPP
 
#include "doubly_linked_list.hpp"
#include "binary_search_tree.hpp"
#include <cstdint>
#include <set>
 
namespace OrderEntry {
 
namespace LOB {
 
// ---------------------------------------------------------------------------
// MARK: Types
// ---------------------------------------------------------------------------
 
enum class Side : bool { Sell = false, Buy = true };
 
inline Side operator!(Side side) {
    return static_cast<Side>(!static_cast<bool>(side));
}
 
typedef uint64_t UID;
typedef uint32_t Quantity;
typedef uint64_t Price;
 
// ---------------------------------------------------------------------------
// MARK: Order
// ---------------------------------------------------------------------------
 
// forward declare the `Account` structure so `Order` can reference it
struct Account;
// forward declare the `Limit` structure so `Order` can reference it
struct Limit;
 
struct Order : DLL::Node {
    const UID uid = 0;
    const Side side = Side::Sell;
    Quantity quantity = 0;
    const Price price = 0;
    Limit* limit = nullptr;
    Account* account = nullptr;
 
    Order() : DLL::Node() { }
 
    Order(
        UID uid_,
        Side side_,
        Quantity quantity_,
        Price price_,
        Limit* limit_ = nullptr,
        Account* account_ = nullptr
    ) :
        DLL::Node(),
        uid(uid_),
        side(side_),
        quantity(quantity_),
        price(price_),
        limit(limit_),
        account(account_) { }
};
 
// ---------------------------------------------------------------------------
// MARK: Limit
// ---------------------------------------------------------------------------
 
typedef uint32_t Count;
typedef uint64_t Volume;
 
struct Limit : BST::Node<Price> {
    Count count = 0;
    const uint32_t _padding = 0;
    Volume volume = 0;
    Order* order_head = nullptr;
    Order* order_tail = nullptr;
 
    Limit() : BST::Node<Price>() { }
 
    explicit Limit(Order* order) :
        BST::Node<Price>(order->price),
        count(1),
        volume(order->quantity),
        order_head(order),
        order_tail(order) { }
};
 
// ---------------------------------------------------------------------------
// MARK: Account
// ---------------------------------------------------------------------------
 
typedef int64_t Shares;
typedef int64_t Capital;
 
struct Account {
    Shares shares = 0;
    Capital capital = 0;
    std::set<Order*> orders= {};
 
    Account(Shares shares_ = 0, Capital capital_ = 0) :
        shares(shares_),
        capital(capital_) { }
 
    inline void limit(Order* order) { orders.insert(order); }
 
    inline void cancel(Order* order) { orders.erase(order); }
 
    inline void fill(Side side, Quantity quantity, Price price) {
        switch (side) {
            case Side::Sell: {
                shares -= quantity;
                capital += quantity * price;
                break;
            }
            case Side::Buy: {
                shares += quantity;
                capital -= quantity * price;
                break;
            }
        }
    }
 
    inline virtual void limit_fill(Order* limit, Order* market) {
        cancel(limit);
        fill(limit->side, limit->quantity, limit->price);
    }
 
    inline virtual void limit_partial(Order* limit, Order* market) {
        fill(limit->side, market->quantity, limit->price);
    }
 
    inline virtual void market_fill(Order* limit, Order* market) {
        fill(market->side, market->quantity, limit->price);
    }
 
    inline virtual void market_partial(Order* limit, Order* market) {
        fill(market->side, limit->quantity, limit->price);
    }
};
 
}  // namespace LOB
 
}  // namespace OrderEntry
 
#endif  // ORDER_ENTRY_LIMIT_ORDER_BOOK_STRUCTURES_HPP