Json.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _JSON_H_
#define _JSON_H_
 
#include <boost/json.hpp>
#include <exception>
#include <fstream>
#include <iostream>
 
#include "../Circuit/Factory.h"
#include "../qasm/QasmCirc.h"
 
namespace Json {
 
template <typename Time = Types::time_type>
class JsonParserMaestro {
 public:
  static boost::json::value ParseString(const char *str) {
    boost::system::error_code ec;
    std::string strs(str);
    std::stringstream ss(strs);
    return Read(ss, ec);
  }
 
  std::shared_ptr<Circuits::Circuit<Time>> ParseCircuit(const char *str) const {
    const boost::json::value circuitJson = ParseString(str);
 
    std::shared_ptr<Circuits::Circuit<Time>> circuit;
 
    if (circuitJson.is_array()) {
      const auto circuitArray = circuitJson.as_array();
      circuit = ParseCircuitArray(circuitArray);
    } else if (circuitJson.is_object()) {
      std::string circuitStr;
      const auto jsonObject = circuitJson.as_object();
      if (jsonObject.contains("qasm")) {
        const auto qasmValue = jsonObject.at("qasm");
        if (qasmValue.is_string()) circuitStr = qasmValue.as_string().c_str();
      } else if (jsonObject.contains("QASM")) {
        const auto qasmValue = jsonObject.at("QASM");
        if (qasmValue.is_string()) circuitStr = qasmValue.as_string().c_str();
      }
      if (circuitStr.empty()) return nullptr;
 
      // QASM 2.0 format
      qasm::QasmToCirc<> parser;
      std::string qasmInput(circuitStr);
      circuit = parser.ParseAndTranslate(qasmInput);
    } else
      return nullptr;
 
    return circuit;
  }
 
  static std::string GetConfigString(const std::string &config,
                                     const boost::json::value &jsonConfig) {
    if (jsonConfig.is_object()) {
      const auto jsonObject = jsonConfig.as_object();
 
      if (jsonObject.contains(config)) {
        const auto configValue = jsonObject.at(config);
        if (configValue.is_string())
          return configValue.as_string().c_str();
        else if (configValue.is_number()) {
          if (configValue.is_int64())
            return std::to_string(configValue.as_int64());
          else if (configValue.is_uint64())
            return std::to_string(configValue.as_uint64());
          else if (configValue.is_double())
            return std::to_string(configValue.as_double());
        } else if (configValue.is_bool()) {
          return configValue.as_bool() ? "true" : "false";
        }
      }
    }
 
    return "";
  }
 
 private:
  std::shared_ptr<Circuits::Circuit<Time>> ParseCircuitArray(
      const boost::json::array &circuitArray) const {
    const auto circuit = std::make_shared<Circuits::Circuit<Time>>();
 
    for (auto operationJson : circuitArray) {
      if (!operationJson.is_object())
        throw std::runtime_error("Circuit operation must be an object.");
 
      auto operationObject = operationJson.as_object();
      if (!operationObject.contains(nameString))
        throw std::runtime_error("Circuit operation does not have a type.");
      else if (!operationObject.at(nameString).is_string())
        throw std::runtime_error("Circuit operation type must be a string.");
 
      const boost::json::string type =
          operationObject.at(nameString).as_string();
 
      if (type != "id")
        circuit->AddOperation(ParseOperation(type, operationObject));
    }
 
    return circuit;
  }
 
  std::shared_ptr<Circuits::IOperation<Time>> ParseOperation(
      const boost::json::string &type, boost::json::object &obj) const {
    std::shared_ptr<Circuits::IOperation<Time>> operation;
 
    if (type == measurementString)
      operation = ParseMeasurement(obj);
    else
      operation = ParseGate(type, obj);
 
    return operation;
  }
 
  std::shared_ptr<Circuits::MeasurementOperation<Time>> ParseMeasurement(
      boost::json::object &obj) const {
    const auto qubits = ParseQubits(obj);
    auto cbits = ParseCbits(obj);
    if (cbits.empty())
      cbits = std::vector<size_t>(qubits.begin(), qubits.end());
 
    if (qubits.size() != cbits.size())
      throw std::runtime_error("Number of qubits and cbits must be the same.");
 
    std::vector<std::pair<Types::qubit_t, size_t>> qs;
 
    for (size_t i = 0; i < qubits.size(); i++)
      qs.push_back(std::make_pair(qubits[i], cbits[i]));
 
    const auto operation =
        std::static_pointer_cast<Circuits::MeasurementOperation<Time>>(
            Circuits::CircuitFactory<Time>::CreateMeasurement(qs));
 
    return operation;
  }
 
  std::shared_ptr<Circuits::IOperation<Time>> ParseGate(
      const boost::json::string &type, boost::json::object &obj) const {
    const std::string gateName = type.c_str();
 
    const auto qubits = ParseQubits(obj);
    if (qubits.empty())
      throw std::runtime_error("No qubits specified.");
    else if (qubits.size() > 3)
      throw std::runtime_error("Number of qubits must be 1, 2, or 3.");
 
    Circuits::QuantumGateType gateType;
 
    if (gatesMap.find(gateName) == gatesMap.end())
      throw std::runtime_error("Gate type not supported.");
 
    gateType = gatesMap.at(gateName);
 
    // parse gate parameters
    const auto parameters = ParseParameters(obj);
 
    const auto operation = Circuits::CircuitFactory<Time>::CreateGate(
        gateType, qubits[0], qubits.size() > 1 ? qubits[1] : 0,
        qubits.size() > 2 ? qubits[2] : 0,
        parameters.size() > 0 ? parameters[0] : 0.,
        parameters.size() > 1 ? parameters[1] : 0.,
        parameters.size() > 2 ? parameters[2] : 0.,
        parameters.size() > 3 ? parameters[3] : 0.);
 
    // check if the number of qubits is correct for the gate
 
    if (operation->GetNumQubits() != qubits.size())
      throw std::runtime_error(
          "The specified number of qubits does not match the number of qubits "
          "required by the gate type.");
 
    // TODO: check parameters?
 
    // check if it's a classically controlled gate
    if (obj.contains("conditional_reg")) {
      auto cond = obj.at("conditional_reg");
      unsigned long long int cbit = 0;
      if (cond.is_uint64())
        cbit = cond.as_uint64();
      else if (cond.is_int64())
        cbit = static_cast<unsigned long long int>(cond.as_int64());
      else if (cond.is_array()) {
        auto arr = cond.as_array();
        if (arr.size() != 1 || !arr[0].is_number())
          throw std::runtime_error(
              "Conditional register must be a single integer.");
 
        if (arr[0].is_uint64())
          cbit = arr[0].as_uint64();
        else if (arr[0].is_int64())
          cbit = static_cast<unsigned long long int>(arr[0].as_int64());
        else
          throw std::runtime_error(
              "Conditional register must be an integer or "
              "an array of one integer.");
      } else
        throw std::runtime_error(
            "Conditional register must be an integer or "
            "an array of one integer.");
 
      return Circuits::CircuitFactory<Time>::CreateSimpleConditionalGate(
          operation, cbit);
    }
 
    return std::static_pointer_cast<Circuits::IOperation<Time>>(operation);
  }
 
  std::vector<double> ParseParameters(boost::json::object &obj) const {
    std::vector<double> parameters;
 
    if (obj.contains(paramsString) && !obj.at(paramsString).is_array())
      throw std::runtime_error("Parameters must be an array.");
 
    auto paramsJson =
        (obj.contains(paramsString) ? obj.at(paramsString).as_array()
                                    : boost::json::array());
    for (auto param : paramsJson) {
      if (!param.is_number())
        throw std::runtime_error("Parameter must be a number.");
      else if (param.is_double())
        parameters.push_back(param.as_double());
      else if (param.is_int64())
        parameters.push_back(static_cast<double>(param.as_int64()));
      else
        parameters.push_back(static_cast<double>(param.as_uint64()));
    }
 
    return parameters;
  }
 
  std::vector<Types::qubit_t> ParseQubits(
      const boost::json::object &obj) const {
    std::vector<Types::qubit_t> qubits;
 
    if (!obj.contains(qubitsString))
      throw std::runtime_error("No Qubits specified.");
    else if (!obj.at(qubitsString).is_array())
      throw std::runtime_error("Qubits must be an array.");
    else if (obj.at(qubitsString).as_array().size() == 0)
      throw std::runtime_error("Qubits array must not be empty.");
 
    auto qubitsJson = obj.at(qubitsString).as_array();
    for (auto qubit : qubitsJson) {
      if (!qubit.is_int64() && !qubit.is_uint64())
        throw std::runtime_error("Number of qubits must be an integer.");
      else if (qubit.is_int64())
        qubits.push_back(qubit.as_int64());
      else
        qubits.push_back(qubit.as_uint64());
    }
 
    return qubits;
  }
 
  std::vector<size_t> ParseCbits(const boost::json::object &obj,
                                 bool mustBeSpecified = false) const {
    std::vector<size_t> cbits;
 
    if (mustBeSpecified) {
      if (!obj.contains(memoryString))
        throw std::runtime_error("No Cbits specified.");
      else if (!obj.at(memoryString).is_array())
        throw std::runtime_error("Cbits must be an array.");
      else if (obj.at(memoryString).as_array().size() == 0)
        throw std::runtime_error("Cbits array must not be empty.");
    } else if (obj.contains(memoryString) && !obj.at(memoryString).is_array())
      throw std::runtime_error("Cbits must be an array.");
 
    auto cbitsJson =
        (obj.contains(memoryString) ? obj.at(memoryString).as_array()
                                    : boost::json::array());
    for (auto cbit : cbitsJson) {
      if (!cbit.is_int64() && !cbit.is_uint64())
        throw std::runtime_error("Number of cbits must be an integer.");
      else if (cbit.is_int64())
        cbits.push_back(cbit.as_int64());
      else
        cbits.push_back(cbit.as_uint64());
    }
 
    return cbits;
  }
 
  static boost::json::value ParseString(const std::string &str,
                                        boost::system::error_code &ec) {
    std::stringstream ss(str);
    return Read(ss, ec);
  }
 
  static boost::json::value Parse(std::istream &is,
                                  boost::system::error_code &ec) {
    return Read(is, ec);
  }
 
  static boost::json::value Read(std::istream &is,
                                 boost::system::error_code &ec) {
    boost::json::stream_parser p;
    std::string line;
    while (std::getline(is, line)) {
      p.write(line, ec);
      if (ec) return nullptr;
    }
    p.finish(ec);
    if (ec) return nullptr;
 
    return p.release();
  }
 
  const std::string circuitString = "instructions";
  const std::string nameString = "name";
  const std::string measurementString = "measure";
 
  const std::string qubitsString = "qubits";
  const std::string paramsString = "params";
  const std::string memoryString = "clbits";
 
  const std::unordered_map<std::string, Circuits::QuantumGateType> gatesMap = {
      {"p", Circuits::QuantumGateType::kPhaseGateType},
      {"x", Circuits::QuantumGateType::kXGateType},
      {"y", Circuits::QuantumGateType::kYGateType},
      {"z", Circuits::QuantumGateType::kZGateType},
      {"h", Circuits::QuantumGateType::kHadamardGateType},
      {"s", Circuits::QuantumGateType::kSGateType},
      {"sdg", Circuits::QuantumGateType::kSdgGateType},
      {"t", Circuits::QuantumGateType::kTGateType},
      {"tdg", Circuits::QuantumGateType::kTdgGateType},
      {"sx", Circuits::QuantumGateType::kSxGateType},
      {"sxdg", Circuits::QuantumGateType::kSxDagGateType},
      {"k", Circuits::QuantumGateType::kKGateType},
      {"rx", Circuits::QuantumGateType::kRxGateType},
      {"ry", Circuits::QuantumGateType::kRyGateType},
      {"rz", Circuits::QuantumGateType::kRzGateType},
      {"u", Circuits::QuantumGateType::kUGateType},
      {"u1", Circuits::QuantumGateType::kUGateType},
      {"u2", Circuits::QuantumGateType::kUGateType},
      {"u3", Circuits::QuantumGateType::kUGateType},
      {"swap", Circuits::QuantumGateType::kSwapGateType},
      {"cx", Circuits::QuantumGateType::kCXGateType},
      {"cy", Circuits::QuantumGateType::kCYGateType},
      {"cz", Circuits::QuantumGateType::kCZGateType},
      {"cp", Circuits::QuantumGateType::kCPGateType},
      {"crx", Circuits::QuantumGateType::kCRxGateType},
      {"cry", Circuits::QuantumGateType::kCRyGateType},
      {"crz", Circuits::QuantumGateType::kCRzGateType},
      {"ch", Circuits::QuantumGateType::kCHGateType},
      {"csx", Circuits::QuantumGateType::kCSxGateType},
      {"csxdg", Circuits::QuantumGateType::kCSxDagGateType},
      {"cu", Circuits::QuantumGateType::kCUGateType},
      {"cswap", Circuits::QuantumGateType::kCSwapGateType},
      {"ccx",
       Circuits::QuantumGateType::kCCXGateType}}; 
};
 
}  // namespace Json
 
#endif  // !_JSON_H_