Converter.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUITCONVERTER_H_
#define _CIRCUITCONVERTER_H_
 
#include "Circuit.h"
 
namespace Circuits {
 
template <typename Time = Types::time_type>
class Converter {
 public:
  static std::shared_ptr<Circuit<Time>> ToCircuit(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kComposite)
      return nullptr;
 
    return Convert<Circuit<Time>>(operation);
  }
 
  static std::shared_ptr<IQuantumGate<Time>> ToQuantumGate(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kGate)
      return nullptr;
 
    return Convert<IQuantumGate<Time>>(operation);
  }
 
  static std::shared_ptr<SingleQubitGate<Time>> ToSingleQubitGate(
      const std::shared_ptr<IOperation<Time>> &operation) {
    auto op = ToQuantumGate(operation);
    if (!op || op->GetNumQubits() != 1) return nullptr;
 
    return Convert<SingleQubitGate<Time>>(operation);
  }
 
  static std::shared_ptr<TwoQubitsGate<Time>> ToTwoQubitsGate(
      const std::shared_ptr<IOperation<Time>> &operation) {
    auto op = ToQuantumGate(operation);
    if (!op || op->GetNumQubits() != 2) return nullptr;
 
    return Convert<TwoQubitsGate<Time>>(operation);
  }
 
  static std::shared_ptr<ThreeQubitsGate<Time>> ToThreeQubitsGate(
      const std::shared_ptr<IOperation<Time>> &operation) {
    auto op = ToQuantumGate(operation);
    if (!op || op->GetNumQubits() != 3) return nullptr;
 
    return Convert<ThreeQubitsGate<Time>>(operation);
  }
 
  // TODO: Add for specific quantum gates
 
  static std::shared_ptr<Random<Time>> ToRandom(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kRandomGen)
      return nullptr;
 
    return Convert<Random<Time>>(operation);
  }
 
  static std::shared_ptr<Reset<Time>> ToReset(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kReset)
      return nullptr;
 
    return Convert<Reset<Time>>(operation);
  }
 
  static std::shared_ptr<MeasurementOperation<Time>> ToMeasurement(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kMeasurement)
      return nullptr;
 
    return Convert<MeasurementOperation<Time>>(operation);
  }
 
  static std::shared_ptr<ConditionalGate<Time>> ToConditionalGate(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation || operation->GetType() != OperationType::kConditionalGate)
      return nullptr;
 
    return Convert<ConditionalGate<Time>>(operation);
  }
 
  static std::shared_ptr<ConditionalMeasurement<Time>> ToConditionalMeasurement(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation ||
        operation->GetType() != OperationType::kConditionalMeasurement)
      return nullptr;
 
    return Convert<ConditionalMeasurement<Time>>(operation);
  }
 
  static std::shared_ptr<ConditionalRandomGen<Time>> ToConditionalRandom(
      const std::shared_ptr<IOperation<Time>> &operation) {
    if (!operation ||
        operation->GetType() != OperationType::kConditionalRandomGen)
      return nullptr;
 
    return Convert<ConditionalRandomGen<Time>>(operation);
  }
 
  static std::shared_ptr<EqualCondition> ToEqualCondition(
      const std::shared_ptr<ICondition> &cond) {
    if (!cond) return nullptr;
 
    return std::static_pointer_cast<EqualCondition>(cond);
  }
 
 private:
  template <typename T>
  static std::shared_ptr<T> Convert(
      const std::shared_ptr<IOperation<Time>> &operation) {
    return std::static_pointer_cast<T>(operation);
  }
};
 
}  // namespace Circuits
 
#endif