Method parse

runtime/common/RecordLogParser.cpp:15–65

#include "cudaq/runtime/logger/logger.h"

void cudaq::RecordLogParser::parse(const std::string &outputLog) {
  ScopedTraceWithContext(cudaq::TIMING_RUN, "RecordLogParser::parse");
  CUDAQ_DBG("Parsing log:\n{}", outputLog);
  std::vector<std::string> lines = cudaq::split(outputLog, '\n');
  if (lines.empty())
    return;

  // Collect log from a single shot and process it only if it is successful.
  bool processingShot = false;
  // Maintain the starting index of each shot's data
  std::size_t shotStart = 0;

  for (std::size_t idx = 0; idx < lines.size(); ++idx) {
    const auto &line = lines[idx];
    std::vector<std::string> entries = cudaq::split(line, '\t');
    if (entries.empty())
      continue;

    const std::string &recordType = entries[0];
    if (recordType == "HEADER")
      handleHeader(entries);
    else if (recordType == "METADATA")
      handleMetadata(entries);
    else if (recordType == "START") {
      processingShot = true;
      shotStart = 0;
    } else if (recordType == "OUTPUT") {
      if (processingShot)
        shotStart = shotStart == 0 ? idx : shotStart;
      else
        handleOutput(entries);
    } else if (recordType == "END") {
      if (entries.size() < 2)
        throw std::runtime_error("Missing shot status");
      if (entries[1] == "0") {
        if (processingShot) {
          // Successful shot, process it
          for (std::size_t j = shotStart; j < idx; ++j)
            handleOutput(cudaq::split(lines[j], '\t'));
        }
      } else {
        CUDAQ_DBG("Discarding shot data due to non-zero END status.");
      }
      processingShot = false;
      shotStart = 0;
      containerMeta.reset();
    } else {
      throw std::runtime_error("Invalid record type: " + recordType);
    }
  }
}

void cudaq::RecordLogParser::handleHeader(
    const std::vector<std::string> &entries) {