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