order.h

Go to the documentation of this file.

 
#ifndef CPPTRADER_MATCHING_ORDER_H
#define CPPTRADER_MATCHING_ORDER_H
 
#include "errors.h"
 
#include "containers/list.h"
#include "utility/iostream.h"
 
#include <algorithm>
#include <cstdint>
#include <limits>
 
namespace CppTrader {
namespace Matching {
 
 
enum class OrderSide : uint8_t
{
    BUY,
    SELL
};
 
template <class TOutputStream>
TOutputStream& operator<<(TOutputStream& stream, OrderSide side);
 
 
enum class OrderType : uint8_t
{
    MARKET,
    LIMIT,
    STOP,
    STOP_LIMIT,
    TRAILING_STOP,
    TRAILING_STOP_LIMIT
};
 
template <class TOutputStream>
TOutputStream& operator<<(TOutputStream& stream, OrderType type);
 
 
enum class OrderTimeInForce : uint8_t
{
    GTC,    
    IOC,    
    FOK,    
    AON     
};
 
template <class TOutputStream>
TOutputStream& operator<<(TOutputStream& stream, OrderTimeInForce tif);
 
 
struct Order
{
    uint64_t Id;
    uint32_t SymbolId;
    OrderType Type;
    OrderSide Side;
    uint64_t Price;
    uint64_t StopPrice;
 
    uint64_t Quantity;
    uint64_t ExecutedQuantity;
    uint64_t LeavesQuantity;
 
    OrderTimeInForce TimeInForce;
 
 
    uint64_t MaxVisibleQuantity;
    uint64_t HiddenQuantity() const noexcept { return (LeavesQuantity > MaxVisibleQuantity) ? (LeavesQuantity - MaxVisibleQuantity) : 0; }
    uint64_t VisibleQuantity() const noexcept { return std::min(LeavesQuantity, MaxVisibleQuantity); }
 
 
    uint64_t Slippage;
 
 
    int64_t TrailingDistance;
 
    int64_t TrailingStep;
 
    Order() noexcept = default;
    Order(uint64_t id, uint32_t symbol, OrderType type, OrderSide side, uint64_t price, uint64_t stop_price, uint64_t quantity,
        OrderTimeInForce tif = OrderTimeInForce::GTC,
        uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max(),
        uint64_t slippage = std::numeric_limits<uint64_t>::max(),
        int64_t trailing_distance = 0,
        int64_t trailing_step = 0) noexcept;
    Order(const Order&) noexcept = default;
    Order(Order&&) noexcept = default;
    ~Order() noexcept = default;
 
    Order& operator=(const Order&) noexcept = default;
    Order& operator=(Order&&) noexcept = default;
 
    template <class TOutputStream>
    friend TOutputStream& operator<<(TOutputStream& stream, const Order& order);
 
    bool IsMarket() const noexcept { return Type == OrderType::MARKET; }
    bool IsLimit() const noexcept { return Type == OrderType::LIMIT; }
    bool IsStop() const noexcept { return Type == OrderType::STOP; }
    bool IsStopLimit() const noexcept { return Type == OrderType::STOP_LIMIT; }
    bool IsTrailingStop() const noexcept { return Type == OrderType::TRAILING_STOP; }
    bool IsTrailingStopLimit() const noexcept { return Type == OrderType::TRAILING_STOP_LIMIT; }
 
    bool IsBuy() const noexcept { return Side == OrderSide::BUY; }
    bool IsSell() const noexcept { return Side == OrderSide::SELL; }
 
    bool IsGTC() const noexcept { return TimeInForce == OrderTimeInForce::GTC; }
    bool IsIOC() const noexcept { return TimeInForce == OrderTimeInForce::IOC; }
    bool IsFOK() const noexcept { return TimeInForce == OrderTimeInForce::FOK; }
    bool IsAON() const noexcept { return TimeInForce == OrderTimeInForce::AON; }
 
    bool IsHidden() const noexcept { return MaxVisibleQuantity == 0; }
    bool IsIceberg() const noexcept { return MaxVisibleQuantity < std::numeric_limits<uint64_t>::max(); }
 
    bool IsSlippage() const noexcept { return Slippage < std::numeric_limits<uint64_t>::max(); }
 
    ErrorCode Validate() const noexcept;
 
    static Order Market(uint64_t id, uint32_t symbol, OrderSide side, uint64_t quantity, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order BuyMarket(uint64_t id, uint32_t symbol, uint64_t quantity, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order SellMarket(uint64_t id, uint32_t symbol, uint64_t quantity, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
 
    static Order Limit(uint64_t id, uint32_t symbol, OrderSide side, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order BuyLimit(uint64_t id, uint32_t symbol, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order SellLimit(uint64_t id, uint32_t symbol, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
 
    static Order Stop(uint64_t id, uint32_t symbol, OrderSide side, uint64_t stop_price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order BuyStop(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order SellStop(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
 
    static Order StopLimit(uint64_t id, uint32_t symbol, OrderSide side, uint64_t stop_price, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order BuyStopLimit(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order SellStopLimit(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t price, uint64_t quantity, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
 
    static Order TrailingStop(uint64_t id, uint32_t symbol, OrderSide side, uint64_t stop_price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order TrailingBuyStop(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order TrailingSellStop(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t slippage = std::numeric_limits<uint64_t>::max()) noexcept;
 
    static Order TrailingStopLimit(uint64_t id, uint32_t symbol, OrderSide side, uint64_t stop_price, uint64_t price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order TrailingBuyStopLimit(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
    static Order TrailingSellStopLimit(uint64_t id, uint32_t symbol, uint64_t stop_price, uint64_t price, uint64_t quantity, int64_t trailing_distance, int64_t trailing_step = 0, OrderTimeInForce tif = OrderTimeInForce::GTC, uint64_t max_visible_quantity = std::numeric_limits<uint64_t>::max()) noexcept;
};
 
struct LevelNode;
 
struct OrderNode : public Order, public CppCommon::List<OrderNode>::Node
{
    LevelNode* Level;
 
    OrderNode(const Order& order) noexcept;
    OrderNode(const OrderNode&) noexcept = default;
    OrderNode(OrderNode&&) noexcept = default;
    ~OrderNode() noexcept = default;
 
    OrderNode& operator=(const Order& order) noexcept;
    OrderNode& operator=(const OrderNode&) noexcept = default;
    OrderNode& operator=(OrderNode&&) noexcept = default;
};
 
} // namespace Matching
} // namespace CppTrader
 
#include "order.inl"
 
#endif // CPPTRADER_MATCHING_ORDER_H