stream_generator.cpp

#include <iostream>
#include <fstream>
#include <cstring>
#include <vector>
#include <cstdint>

// Helper to write little-endian values
template<typename T>
void writeLE(std::ostream& out, T value) {
    out.write(reinterpret_cast<const char*>(&value), sizeof(T));
}

void writeAlpha(std::ostream& out, const std::string& str, size_t len) {
    std::string padded = str;
    padded.resize(len, ' ');
    out.write(padded.c_str(), len);
}

class StreamGenerator {
private:
    std::ofstream outFile;
    uint32_t sequenceNo;
    
public:
    StreamGenerator(const std::string& filename) : sequenceNo(1) {
        outFile.open(filename, std::ios::binary);
    }
    
    ~StreamGenerator() {
        outFile.close();
    }
    
    void addOrder(const std::string& symbol, uint64_t orderId, char side, 
                  uint64_t size, int32_t price) {
        std::vector<char> msg(32);
        msg[0] = 'A'; // Message type
        
        // Symbol (3 bytes)
        std::string sym = symbol;
        sym.resize(3, ' ');
        std::memcpy(&msg[1], sym.c_str(), 3);
        
        // Order ID (8 bytes)
        std::memcpy(&msg[4], &orderId, 8);
        
        // Side (1 byte)
        msg[12] = side;
        
        // Reserved (3 bytes)
        msg[13] = msg[14] = msg[15] = ' ';
        
        // Size (8 bytes)
        std::memcpy(&msg[16], &size, 8);
        
        // Price (4 bytes)
        std::memcpy(&msg[24], &price, 4);
        
        // Reserved (4 bytes)
        msg[28] = msg[29] = msg[30] = msg[31] = ' ';
        
        writeMessage(msg);
    }
    
    void updateOrder(const std::string& symbol, uint64_t orderId, char side,
                     uint64_t size, int32_t price) {
        std::vector<char> msg(32);
        msg[0] = 'U';
        
        std::string sym = symbol;
        sym.resize(3, ' ');
        std::memcpy(&msg[1], sym.c_str(), 3);
        std::memcpy(&msg[4], &orderId, 8);
        msg[12] = side;
        msg[13] = msg[14] = msg[15] = ' ';
        std::memcpy(&msg[16], &size, 8);
        std::memcpy(&msg[24], &price, 4);
        msg[28] = msg[29] = msg[30] = msg[31] = ' ';
        
        writeMessage(msg);
    }
    
    void deleteOrder(const std::string& symbol, uint64_t orderId, char side) {
        std::vector<char> msg(16);
        msg[0] = 'D';
        
        std::string sym = symbol;
        sym.resize(3, ' ');
        std::memcpy(&msg[1], sym.c_str(), 3);
        std::memcpy(&msg[4], &orderId, 8);
        msg[12] = side;
        msg[13] = msg[14] = msg[15] = ' ';
        
        writeMessage(msg);
    }
    
    void executeOrder(const std::string& symbol, uint64_t orderId, char side,
                      uint64_t tradedQty) {
        std::vector<char> msg(24);
        msg[0] = 'E';
        
        std::string sym = symbol;
        sym.resize(3, ' ');
        std::memcpy(&msg[1], sym.c_str(), 3);
        std::memcpy(&msg[4], &orderId, 8);
        msg[12] = side;
        msg[13] = msg[14] = msg[15] = ' ';
        std::memcpy(&msg[16], &tradedQty, 8);
        
        writeMessage(msg);
    }
    
private:
    void writeMessage(const std::vector<char>& msgData) {
        uint32_t msgSize = msgData.size();
        
        // Write header
        writeLE(outFile, sequenceNo);
        writeLE(outFile, msgSize);
        
        // Write message data
        outFile.write(msgData.data(), msgSize);
        
        sequenceNo++;
    }
};

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <output_file> [size_mb]" << std::endl;
        return 1;
    }
    
    std::string filename = argv[1];
    int sizeMB = (argc > 2) ? std::atoi(argv[2]) : 0;
    
    StreamGenerator gen(filename);
    
    if (sizeMB > 0) {
        // Generate large test file
        std::cout << "Generating " << sizeMB << "MB test file..." << std::endl;
        
        int messagesPerMB = 1024 * 1024 / 40; // ~40 bytes per message with header
        int totalMessages = sizeMB * messagesPerMB;
        
        for (int i = 0; i < totalMessages; i++) {
            uint64_t orderId = 10000 + i;
            int32_t price = 300000 + (i % 10000);
            uint64_t size = 100 + (i % 5000);
            char side = (i % 2 == 0) ? 'B' : 'S';
            
            int msgType = i % 4;
            if (msgType == 0) {
                gen.addOrder("SB0", orderId, side, size, price);
            } else if (msgType == 1 && i > 0) {
                gen.updateOrder("SB0", orderId - 1, side, size + 100, price + 100);
            } else if (msgType == 2 && i > 1) {
                gen.deleteOrder("SB0", orderId - 2, side);
            } else if (msgType == 3 && i > 2) {
                gen.executeOrder("SB0", orderId - 3, side, 50);
            }
            
            if (i % 10000 == 0) {
                std::cout << "Progress: " << (i * 100 / totalMessages) << "%" << std::endl;
            }
        }
        
        std::cout << "Generated " << totalMessages << " messages" << std::endl;
    } else {
        // Generate test file matching output1.log
        std::cout << "Generating test file matching expected output..." << std::endl;
        
        gen.addOrder("SB0", 1001, 'B', 5000, 318800);
        gen.addOrder("SB0", 1002, 'B', 2986, 315000);
        gen.updateOrder("SB0", 1001, 'B', 4709, 318800);
        gen.addOrder("SB0", 2001, 'S', 360, 318900);
        gen.executeOrder("SB0", 2001, 'S', 201);
        gen.deleteOrder("SB0", 2001, 'S');
        gen.addOrder("SB0", 1003, 'B', 888, 319000);
        gen.executeOrder("SB0", 1003, 'B', 667);
        gen.deleteOrder("SB0", 1003, 'B');
        
        std::cout << "Generated test file: " << filename << std::endl;
    }
    
    return 0;
}