Method frameParserDryRun

app/src/API/Handlers/ProjectHandler.cpp:5915–6002

* @brief Frame parser dry-run: drives extraction + decoder + parser against caller bytes. */

 * @brief Frame parser dry-run: drives extraction + decoder + parser against caller bytes.
 */
API::CommandResponse API::Handlers::ProjectHandler::frameParserDryRun(const QString& id,
                                                                      const QJsonObject& params)
{
  if (!params.contains(QStringLiteral("code")))
    return CommandResponse::makeError(
      id, ErrorCode::MissingParam, QStringLiteral("Missing required parameter: code"));

  if (!params.contains(QStringLiteral("language")))
    return CommandResponse::makeError(
      id, ErrorCode::MissingParam, QStringLiteral("Missing required parameter: language"));

  if (!params.contains(QStringLiteral("inputBytes"))
      && !params.contains(QStringLiteral("inputBytesHex")))
    return CommandResponse::makeError(
      id,
      ErrorCode::MissingParam,
      QStringLiteral("Missing required parameter: inputBytesHex (preferred, binary-safe) or "
                     "inputBytes (UTF-8 text)."));

  const auto bytes = dryRunInputBytes(params);
  if (bytes.isEmpty())
    return CommandResponse::makeError(
      id,
      ErrorCode::InvalidParam,
      QStringLiteral("inputBytes / inputBytesHex were provided but decoded to zero bytes. "
                     "Pass the raw stream in exactly one of them: inputBytesHex as hex digits "
                     "(e.g. '61 2C 62') or inputBytes as UTF-8 text. Empty strings count as "
                     "absent."));

  const auto code     = params.value(QStringLiteral("code")).toString();
  const auto language = params.value(QStringLiteral("language")).toInt();

  DataModel::PipelineSpec spec;
  spec.operationMode = static_cast<SerialStudio::OperationMode>(
    params.value(QStringLiteral("operationMode")).toInt(int(SerialStudio::ProjectFile)));
  spec.frameDetection = static_cast<SerialStudio::FrameDetection>(
    params.value(Keys::FrameDetection).toInt(int(SerialStudio::EndDelimiterOnly)));
  spec.decoderMethod = static_cast<SerialStudio::DecoderMethod>(
    params.value(Keys::DecoderMethod).toInt(int(SerialStudio::PlainText)));
  spec.checksumAlgorithm = params.value(Keys::ChecksumAlgorithm).toString();

  const bool hexDelims = params.value(Keys::HexadecimalDelimiters).toBool(false);
  const auto start     = dryRunDelimiter(params, QString(Keys::FrameStart), hexDelims);
  const auto end       = dryRunDelimiter(params, QString(Keys::FrameEnd), hexDelims);
  if (!start.isEmpty())
    spec.startSequences.append(start);

  if (!end.isEmpty())
    spec.finishSequences.append(end);

  if (spec.operationMode == SerialStudio::QuickPlot && spec.finishSequences.isEmpty()) {
    spec.finishSequences = {QByteArray("\n"), QByteArray("\r\n"), QByteArray("\r")};
    spec.frameDetection  = SerialStudio::EndDelimiterOnly;
  }

  const auto run = DataModel::runFrameParserPipelineWithCode(bytes, spec, code, language);
  if (!run.stageError.isEmpty()) {
    QString message = run.stageError;