messages.hpp

// Structures for limit order book depth 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 DATA_FEED_MESSAGES_HPP
#define DATA_FEED_MESSAGES_HPP
 
#include <array>
#include <chrono>
#include <deque>
#include <iostream>
#include <sstream>
#include "limit_order_book/structures.hpp"
#include "clock.hpp"
 
namespace DataFeed {
 
typedef Clock::TimeStamp TimeStamp;
 
typedef uint32_t SequenceNumber;
 
typedef uint64_t OrderID;
 
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 66 and 'S' is larger. subtracting 66 and performing a boolean
    // condition allows fast conversion from char to double
    return (-2 * static_cast<bool>(static_cast<char>(side) - 'B')) + 1;
}
 
inline constexpr bool side_to_bool(Side side) {
    // 'B' is 66 and 'S' is larger. subtracting 66 and performing a boolean
    // condition allows fast conversion from char to double
    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;
 
namespace Messages {
 
typedef std::array<char, 40> Packet;
 
typedef std::deque<Packet> PacketQueue;
 
enum class MessageID : char {
    Clear =          'c',  // clear the book
    AddOrder =       'a',  // add an order
    DeleteOrder =    'd',  // delete an order
    Trade =          't',  // a trade occurred
    StartOfSession = 's',  // start of trading
    EndOfSession =   'e',  // end of trading
};
 
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;
    const TimeStamp time;
 
    Header(
        uint16_t length_,
        MessageID uid_,
        SequenceNumber sequence_ = 0,
        TimeStamp time_ = 0
    ) :
        length(length_),
        uid(uid_),
        sequence(sequence_),
        time(time_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const Header& header
    ) {
        stream << "Header("
            << "length=" << static_cast<int>(header.length) << ","
            << "uid='" << header.uid << "',"
            << "sequence=" << header.sequence  << ","
            << "time=" << header.time << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: Clear
// ---------------------------------------------------------------------------
 
struct Clear {
    const Header header;
 
    Clear(SequenceNumber sequence = 0, TimeStamp time = 0) :
        header{sizeof(Clear), MessageID::Clear, sequence, time} { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const Clear& message
    ) {
        stream << "Clear(" << message.header << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: AddOrder
// ---------------------------------------------------------------------------
 
struct AddOrder {
    const Header header;
    const OrderID uid;
    const Price price;
    const Quantity quantity;
    const Side side;
 
    AddOrder(
        OrderID uid_,
        Price price_,
        Quantity quantity_,
        Side side_,
        SequenceNumber sequence = 0,
        TimeStamp time = 0
    ) :
        header{sizeof(AddOrder), MessageID::AddOrder, sequence, time},
        uid(uid_),
        price(price_),
        quantity(quantity_),
        side(side_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const AddOrder& message
    ) {
        stream << "AddOrder(" << message.header << ","
            << "uid=" << message.uid << ","
            << "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: DeleteOrder
// ---------------------------------------------------------------------------
 
struct DeleteOrder {
    const Header header;
    const OrderID uid;
 
    explicit DeleteOrder(
        OrderID uid_,
        SequenceNumber sequence = 0,
        TimeStamp time = 0
    ) :
        header{sizeof(DeleteOrder), MessageID::DeleteOrder, sequence, time},
        uid(uid_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const DeleteOrder& message
    ) {
        stream << "DeleteOrder(" << message.header << ","
            << "uid=" << message.uid << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: Trade
// ---------------------------------------------------------------------------
 
struct Trade {
    const Header header;
    const OrderID uid;
    const Price price;
    const Quantity quantity;
    const Side side;
 
    Trade(
        OrderID uid_,
        Price price_,
        Quantity quantity_,
        Side side_,
        SequenceNumber sequence = 0,
        TimeStamp time = 0
    ) :
        header{sizeof(Trade), MessageID::Trade, sequence, time},
        uid(uid_),
        price(price_),
        quantity(quantity_),
        side(side_) { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const Trade& message
    ) {
        stream << "Trade(" << message.header << ","
            << "uid=" << message.uid << ","
            << "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: StartOfSession
// ---------------------------------------------------------------------------
 
struct StartOfSession {
    const Header header;
 
    StartOfSession(SequenceNumber sequence = 0, TimeStamp time = 0) :
        header{sizeof(StartOfSession), MessageID::StartOfSession, sequence, time} { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const StartOfSession& message
    ) {
        stream << "StartOfSession(" << message.header << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
// ---------------------------------------------------------------------------
// MARK: EndOfSession
// ---------------------------------------------------------------------------
 
struct EndOfSession {
    const Header header;
 
    EndOfSession(SequenceNumber sequence = 0, TimeStamp time = 0) :
        header{sizeof(EndOfSession), MessageID::EndOfSession, sequence, time} { }
 
    inline friend std::ostream& operator<<(
        std::ostream& stream,
        const EndOfSession& message
    ) {
        stream << "EndOfSession(" << message.header << ")";
        return stream;
    }
 
    inline std::string to_string() const {
        std::ostringstream stream;
        stream << this;
        return stream.str();
    }
} __attribute__ ((packed));
 
}  // namespace Messages
 
}  // namespace DataFeed
 
#endif  // DATA_FEED_MESSAGES_HPP