messages.hpp

// Structures for order entry messages.
// 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_MESSAGES_HPP
#define ORDER_ENTRY_MESSAGES_HPP
 
#include <array>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include "limit_order_book/structures.hpp"
#include "clock.hpp"
 
namespace OrderEntry {
 
typedef Clock::TimeStamp TimeStamp;
 
typedef uint32_t SequenceNumber;
 
typedef std::array<char, 4> Username;
 
Username make_username(std::string username) {
    if (username.length() != sizeof(Username))
        throw "username must have " + std::to_string(sizeof(Username)) + " characters!";
    Username arr;
    std::copy(&username[0], &username[0] + sizeof(Username), arr.data());
    return arr;
}
 
typedef std::array<char, 12> Password;
 
Password make_password(std::string password) {
    if (password.length() != sizeof(Password))
        throw "password must have " + std::to_string(sizeof(Password)) + " characters!";
    Password arr;
    std::copy(&password[0], &password[0] + sizeof(Password), arr.data());
    return arr;
}
 
enum class Side : char { Sell = 'S', Buy = 'B' };
 
inline std::ostream& operator<<(std::ostream& stream, const Side& side) {
    stream << static_cast<char>(side);
    return stream;
}
 
inline constexpr double side_to_double(Side side) {
    // B is ASCII 66
    // S is ASCII 83
    // B comes before S in ASCII, if we remove B and have 0, i.e., false, then
    // the side is buy.
    return (-2 * static_cast<bool>(static_cast<char>(side) - 'B')) + 1;
}
 
inline constexpr bool side_to_bool(Side side) {
    // B is ASCII 66
    // S is ASCII 83
    // B comes before S in ASCII, if we remove B and have 0, i.e., false, then
    // the side is buy.
    return not (static_cast<char>(side) - 'B');
}
 
inline constexpr LOB::Side side_to_LOB_side(Side side) {
    return static_cast<LOB::Side>(side_to_bool(side));
}
 
inline constexpr Side bool_to_side(bool side) {
    // B is ASCII 66
    // S is ASCII 83
    // start with ASCII S, which is larger than ASCII B, if side is true remove
    // the difference between ASCII S and B to get ASCII B
    return static_cast<Side>('S' - side * ('S' - 'B'));
}
 
typedef uint32_t Quantity;
 
typedef uint64_t Price;
 
typedef uint64_t OrderID;
 
namespace Messages {
 
typedef std::array<char, 40> Packet;
 
typedef std::deque<Packet> PacketQueue;
 
enum class MessageID : char {
    LoginRequest =    'L',
    LoginResponse =   'l',
    LogoutRequest =   'O',
    LogoutResponse =  'o',
    OrderRequest =    'N',
    OrderResponse =   'n',
    CancelRequest =   'C',
    CancelResponse =  'c',
    ReplaceRequest =  'R', // cancel and replace, but faster (one message)
    ReplaceResponse = 'r',
    // ModifyRequest =   'M', // modify without cancel (decrement order amount)
    // ModifyResponse =  'm',
    PurgeRequest =    'P', // cancel all orders
    PurgeResponse =   'p',
    TradeResponse  =  't'
};
 
inline std::ostream& operator<<(std::ostream& stream, const MessageID& uid) {
    stream << static_cast<char>(uid);
    return stream;
}
 
// ---------------------------------------------------------------------------
// MARK: Header
// ---------------------------------------------------------------------------
 
struct Header {
    const uint16_t length;
    const MessageID uid;
    const uint8_t padding = 0;
    const SequenceNumber sequence;
 
    Header(uint16_t length_, MessageID uid_, SequenceNumber sequence_ = 0) :
        length(length_),
        uid(uid_),
        sequence(sequence_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const Header& header
    ) {
        stream << "Header("
            << "length=" << header.length << ","
            << "uid='" << header.uid << "',"
            << "sequence=" << header.sequence << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: LoginRequest
// ---------------------------------------------------------------------------
 
struct LoginRequest {
    const Header header;
    const Username username;
    const Password password;
 
    LoginRequest(SequenceNumber sequence, Username username_, Password password_) :
        header{sizeof(LoginRequest), MessageID::LoginRequest, sequence},
        username(username_),
        password(password_) { }
 
    inline std::string username_string() const {
        return std::string(std::begin(username), std::end(username));
    }
 
    inline std::string password_string() const {
        return std::string(std::begin(password), std::end(password));
    }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const LoginRequest& message
    ) {
        stream << "LoginRequest(header=" << message.header << ",username=\"";
        stream.write(message.username.data(), 4);
        stream << "\",password=\"";
        stream.write(message.password.data(), 12);
        stream << "\")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: LoginResponse
// ---------------------------------------------------------------------------
 
enum class LoginResponseStatus : char {
    Accepted =          'A',  // the login request was accepted
    NotAuthorized =     'N',  // the credentials are incorrect
    AlreadyAuthorized = 'C',  // the user is already authorized
    SessionInUse =      'B',  // the user is logged in already
};
 
inline std::ostream& operator<<(std::ostream& stream, const LoginResponseStatus& status) {
    stream << static_cast<char>(status);
    return stream;
}
 
struct LoginResponse {
    const Header header;
    const LoginResponseStatus status;
 
    LoginResponse(SequenceNumber sequence, LoginResponseStatus status_) :
        header{sizeof(LoginResponse), MessageID::LoginResponse, sequence},
        status(status_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const LoginResponse& message
    ) {
        stream << "LoginResponse("
            << "header=" << message.header << ","
            << "status='" << message.status << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: LogoutRequest
// ---------------------------------------------------------------------------
 
struct LogoutRequest {
    const Header header;
 
    explicit LogoutRequest(SequenceNumber sequence) :
        header{sizeof(LogoutRequest), MessageID::LogoutRequest, sequence} { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const LogoutRequest& message
    ) {
        stream << "LogoutRequest(header=" << message.header << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: LogoutResponse
// ---------------------------------------------------------------------------
 
enum class LogoutReason : char {
    UserRequested =     'U',  // the user requested to logout
    EndOfDay =          'E',  // the trading day is ending, orders are canceled
    Administrative =    'A',  // administrative reason
    ProtocolViolation = '!'   // the client violated the application protocol
};
 
inline std::ostream& operator<<(std::ostream& stream, const LogoutReason& reason) {
    stream << static_cast<char>(reason);
    return stream;
}
 
struct LogoutResponse {
    const Header header;
    const LogoutReason reason;
 
    LogoutResponse(SequenceNumber sequence, LogoutReason reason_) :
        header{sizeof(LogoutResponse), MessageID::LogoutResponse, sequence},
        reason(reason_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const LogoutResponse& message
    ) {
        stream << "LogoutResponse(header=" << message.header << ","
            << "reason='" << message.reason << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: OrderRequest
// ---------------------------------------------------------------------------
 
static constexpr Price ORDER_PRICE_MARKET = 0;
 
struct OrderRequest {
    const Header header;
    const Price price;
    const Quantity quantity;
    const Side side;
 
    OrderRequest(
        SequenceNumber sequence,
        Price price_,
        Quantity quantity_,
        Side side_
    ) :
        header{sizeof(OrderRequest), MessageID::OrderRequest, sequence},
        price(price_),
        quantity(quantity_),
        side(side_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const OrderRequest& message
    ) {
        stream << "OrderRequest(header=" << message.header << ","
            << "price=" << message.price << ","
            << "quantity=" << message.quantity << ","
            << "side='" << message.side << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: OrderResponse
// ---------------------------------------------------------------------------
 
static constexpr OrderID ORDER_ID_MARKET = 0;
static constexpr OrderID ORDER_ID_REJECTED = 0;
enum class OrderStatus : char { Accepted = 'A', Rejected = 'R' };
 
inline std::ostream& operator<<(std::ostream& stream, const OrderStatus& status) {
    stream << static_cast<char>(status);
    return stream;
}
 
struct OrderResponse {
    const Header header;
    const OrderID order_id;
    const OrderStatus status;
 
    OrderResponse(
        SequenceNumber sequence,
        OrderID order_id_,
        OrderStatus status_
    ) :
        header{sizeof(OrderResponse), MessageID::OrderResponse, sequence},
        order_id(order_id_),
        status(status_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const OrderResponse& message
    ) {
        stream << "OrderResponse(header=" << message.header << ","
            << "order_id=" << message.order_id << ","
            << "status='" << message.status << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: CancelRequest
// ---------------------------------------------------------------------------
 
struct CancelRequest {
    const Header header;
    const OrderID order_id;
 
    CancelRequest(SequenceNumber sequence, OrderID order_id_) :
        header{sizeof(CancelRequest), MessageID::CancelRequest, sequence},
        order_id(order_id_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const CancelRequest& message
    ) {
        stream << "CancelRequest(header=" << message.header << ","
            << "order_id=" << message.order_id << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: CancelResponse
// ---------------------------------------------------------------------------
 
enum class CancelStatus : char { Accepted = 'A', Rejected = 'R' };
 
inline std::ostream& operator<<(std::ostream& stream, const CancelStatus& status) {
    stream << static_cast<char>(status);
    return stream;
}
 
struct CancelResponse {
    const Header header;
    const OrderID order_id;
    const CancelStatus status;
 
    CancelResponse(
        SequenceNumber sequence,
        OrderID order_id_,
        CancelStatus status_
    ) :
        header{sizeof(CancelResponse), MessageID::CancelResponse, sequence},
        order_id(order_id_),
        status(status_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const CancelResponse& message
    ) {
        stream << "CancelResponse(header=" << message.header << ","
            << "order_id=" << message.order_id << ","
            << "status='" << message.status << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: ReplaceRequest
// ---------------------------------------------------------------------------
 
struct ReplaceRequest {
    const Header header;
    const OrderID order_id;
    const Price price;
    const Quantity quantity;
    const Side side;
 
    ReplaceRequest(
        SequenceNumber sequence,
        OrderID order_id_,
        Price price_,
        Quantity quantity_,
        Side side_
    ) :
        header{sizeof(ReplaceRequest), MessageID::ReplaceRequest, sequence},
        order_id(order_id_),
        price(price_),
        quantity(quantity_),
        side(side_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const ReplaceRequest& message
    ) {
        stream << "ReplaceRequest(header=" << message.header << ","
            << "order_id=" << message.order_id << ","
            << "price=" << message.price << ","
            << "quantity=" << message.quantity << ","
            << "side='" << message.side << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: ReplaceResponse
// ---------------------------------------------------------------------------
 
enum class ReplaceStatus : char { Accepted = 'A', Rejected = 'R' };
 
inline std::ostream& operator<<(std::ostream& stream, const ReplaceStatus& status) {
    stream << static_cast<char>(status);
    return stream;
}
 
struct ReplaceResponse {
    const Header header;
    const OrderID canceled;
    const OrderID new_order_id;
    const ReplaceStatus status;
 
    ReplaceResponse(
        SequenceNumber sequence,
        OrderID canceled_,
        OrderID new_order_id_,
        ReplaceStatus status_
    ) :
        header{sizeof(ReplaceResponse), MessageID::ReplaceResponse, sequence},
        canceled(canceled_),
        new_order_id(new_order_id_),
        status(status_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const ReplaceResponse& message
    ) {
        stream << "ReplaceResponse(header=" << message.header << ","
            << "canceled=" << message.canceled << ","
            << "new_order_id=" << message.new_order_id << ","
            << "status='" << message.status << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: PurgeRequest
// ---------------------------------------------------------------------------
 
struct PurgeRequest {
    const Header header;
 
    explicit PurgeRequest(SequenceNumber sequence) :
        header{sizeof(PurgeRequest), MessageID::PurgeRequest, sequence} { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const PurgeRequest& message
    ) {
        stream << "PurgeRequest(header=" << message.header << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: PurgeResponse
// ---------------------------------------------------------------------------
 
enum class PurgeStatus : char { Accepted = 'A', Rejected = 'R' };
 
inline std::ostream& operator<<(std::ostream& stream, const PurgeStatus& status) {
    stream << static_cast<char>(status);
    return stream;
}
 
struct PurgeResponse {
    const Header header;
    const PurgeStatus status;
 
    PurgeResponse(SequenceNumber sequence, PurgeStatus status_) :
        header{sizeof(PurgeResponse), MessageID::PurgeResponse, sequence},
        status(status_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const PurgeResponse& message
    ) {
        stream << "PurgeResponse(header=" << message.header << ","
            << "status='" << message.status << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: TradeResponse
// ---------------------------------------------------------------------------
 
struct TradeResponse {
    const Header header;
    const OrderID order_id;
    const Price price;
    const Quantity quantity;
    const Quantity leaves_quantity;
    const Side side;
 
    TradeResponse(
        SequenceNumber sequence,
        OrderID order_id_,
        Price price_,
        Quantity quantity_,
        Quantity leaves_quantity_,
        Side side_
    ) :
        header{sizeof(TradeResponse), MessageID::TradeResponse, sequence},
        order_id(order_id_),
        price(price_),
        quantity(quantity_),
        leaves_quantity(leaves_quantity_),
        side(side_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const TradeResponse& message
    ) {
        stream << "TradeResponse(header=" << message.header << ","
            << "order_id=" << message.order_id << ","
            << "price=" << message.price << ","
            << "quantity=" << message.quantity << ","
            << "leaves_quantity=" << message.leaves_quantity << ","
            << "side='" << message.side << "')";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
}  // namespace Messages
 
}  // namespace OrderEntry
 
#endif  // ORDER_ENTRY_MESSAGES_HPP