class QPanda::JudgeTwoNodeIterIsSwappable

Overview

Judge two node is swappable. More…

#include <JudgeTwoNodeIterIsSwappable.h>

class JudgeTwoNodeIterIsSwappable: public QPanda::TraverseByNodeIter
{
public:
    // structs

    struct NodeInCircuitInfo;

    // classes

    class AbstractJudgeStatueInterface;
    class CanNotBeExchange;
    class CoubleBeExchange;
    class OnFoundAllNodes;
    class OnInitStatue;
    class OnJudgeMatrix;
    class OnPickUpNode;

    // construction

    JudgeTwoNodeIterIsSwappable(QProg prog, NodeIter& nodeItr_1, NodeIter& nodeItr_2);

    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    bool get_result();
    virtual void traverse_qprog();
    bool judge_node_type();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Judge two node is swappable.

Construction

JudgeTwoNodeIterIsSwappable(QProg prog, NodeIter& nodeItr_1, NodeIter& nodeItr_2)

Constructor of JudgeTwoNodeIterIsSwappable.

Methods

bool get_result()

get final judge result

Returns:

bool

virtual void traverse_qprog()

start traverse a quantum prog

bool judge_node_type()

judge the input two node type

Returns:

if any input node is unswappable type, return false, else return true.