Types.h

Go to the documentation of this file.

//
// Created by sujal on 21-10-2025.
//
 
#pragma once
#include "Instrument.h"
#include <array>
#include <cstdint>
#include <stdexcept>
#include <string>
 
namespace common {
    enum class OrderSide : uint8_t {
        Buy, 
        Sell, 
    };
 
    enum class OrderType : uint8_t {
        Limit, 
        Market, 
        Stop, 
        StopLimit 
    };
 
    enum class OrderStatus : uint8_t {
        New, 
        PartiallyFilled, 
        Filled, 
        Cancelled, 
        Rejected 
    };
 
    enum class TimeInForce : uint8_t {
        DAY, 
        GTC, 
        IOC, 
        FOK, 
        MOO, 
        MOC, 
    };
 
    // --- OrderSide Serialization ---
    constexpr std::array<std::string_view, 2> order_side_names
            = {"Buy", "Sell"};
 
    inline std::string to_string(OrderSide side)
    {
        return std::string(order_side_names[static_cast<size_t>(side)]);
    }
 
    inline OrderSide from_string_OrderSide(std::string_view name)
    {
        for (size_t i = 0; i < order_side_names.size(); ++i)
            if (order_side_names[i] == name) return static_cast<OrderSide>(i);
        throw std::invalid_argument("Unknown OrderSide name");
    }
 
    // --- OrderType Serialization ---
    constexpr std::array<std::string_view, 2> order_type_names
            = {"Limit", "Market"};
 
    inline std::string to_string(OrderType type)
    {
        return std::string(order_type_names[static_cast<size_t>(type)]);
    }
 
    inline OrderType from_string_OrderType(std::string_view name)
    {
        for (size_t i = 0; i < order_type_names.size(); ++i)
            if (order_type_names[i] == name) return static_cast<OrderType>(i);
        throw std::invalid_argument("Unknown OrderType name");
    }
 
    // --- OrderStatus Serialization ---
    constexpr std::array<std::string_view, 5> order_status_names
            = {"New", "PartiallyFilled", "Filled", "Cancelled", "Rejected"};
 
    inline std::string to_string(OrderStatus status)
    {
        return std::string(order_status_names[static_cast<size_t>(status)]);
    }
 
    inline OrderStatus from_string_OrderStatus(std::string_view name)
    {
        for (size_t i = 0; i < order_status_names.size(); ++i)
            if (order_status_names[i] == name)
                return static_cast<OrderStatus>(i);
        throw std::invalid_argument("Unknown OrderStatus name");
    }
 
    // --- TimeInForce Serialization ---
    constexpr std::array<std::string_view, 6> time_in_force_names
            = {"DAY", "GTC", "IOC", "FOK", "MOO", "MOC"};
 
    inline std::string to_string(TimeInForce tif)
    {
        return std::string(time_in_force_names[static_cast<size_t>(tif)]);
    }
 
    inline TimeInForce from_string_TimeInForce(std::string_view name)
    {
        for (size_t i = 0; i < time_in_force_names.size(); ++i)
            if (time_in_force_names[i] == name)
                return static_cast<TimeInForce>(i);
        throw std::invalid_argument("Unknown TimeInForce name");
    }
 
    using Price = double;
    using Quantity = uint64_t;
    using OrderID = uint64_t;
    using TradeID = uint64_t;
    using Symbol = Instrument;
    using ClientID = std::string;
    using SessionID = uint64_t;
} // namespace common