class QPanda::QProgBuilder

Quantum Program Builder.

#include <OriginIRToQProg.h>

class QProgBuilder
{
public:
    // enums

    enum GateType;

    // construction

    QProgBuilder(
        QuantumMachine* qm,
        QVec& qv,
        std::vector<ClassicalCondition>& cv
        );

    // methods

    QProg get_qprog();
    size_t get_qubits_size();
    size_t get_cbits_size();
    void set_define_qgate_function(const DefineQGateContent& define_qgate);
    DefineQGateContent get_define_qgate_function(const std::string& gate_name);
    void alloc_qubit(int num);
    void alloc_cbit(int num);
    size_t add_prog();

    void insert_subprog(
        size_t progid_dst,
        size_t progid_src
        );

    size_t add_qgate(
        GateType type,
        std::vector<int> index,
        std::vector<double> parameters
        );

    size_t add_qgate_cc(
        GateType type,
        std::vector<size_t> exprid,
        std::vector<int> index,
        std::vector<double> parameters
        );

    size_t add_measure_literal(
        size_t qidx,
        size_t cidx
        );

    size_t add_measure_cc(
        size_t exprid,
        size_t cidx
        );

    size_t add_reset_literal(size_t qidx);
    size_t add_reset_cc(size_t exprid);

    size_t add_barrier_literal(
        size_t exprid,
        QVec qv
        );

    size_t add_barrier_cc(
        size_t exprid,
        QVec qv
        );

    size_t add_expr_stat(size_t exprid);

    size_t make_qif(
        size_t exprid,
        size_t progid
        );

    size_t make_qifelse(
        size_t exprid,
        size_t progid_true,
        size_t progid_false
        );

    size_t make_qwhile(
        size_t exprid,
        size_t progid
        );

    void delete_prog(size_t progid);
    size_t cc_init_id(size_t cidx);
    size_t cc_init_literal(double value);

    size_t cc_op_cc(
        size_t exprid1,
        size_t exprid2,
        int op_type
        );

    size_t cc_op_literal(
        size_t exprid1,
        double literal2,
        int op_type
        );

    size_t literal_op_cc(
        double literal1,
        size_t exprid2,
        int op_type
        );

    size_t op_cc(
        size_t exprid,
        int op_type
        );

    void make_dagger(size_t progid);
    size_t make_dagger_new(size_t progid);

    void make_control(
        size_t progid,
        std::vector<int> idx
        );

    size_t make_control_new(
        size_t progid,
        std::vector<int> idx
        );

    QVec make_qvec(
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    void make_control_cc(
        size_t progid,
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    size_t make_control_cc_new(
        size_t progid,
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    static GateType get_gatetype(std::string gatename);
};