vector MessageManager::incomingHandler()

in samplecode/psi/SMCClient/isv_app/MessageManager.cpp [201:289]
84 lines of code
22 McCabe index (conditional complexity)

vector<string> MessageManager::incomingHandler(string v, int type) {
    vector<string> res;

    if (!v.empty()) {
        string s;
        bool ret;

        switch (type) {
        case RA_MSG0: {
            Messages::MessageMsg0 msg0;
            ret = msg0.ParseFromString(v);
            if (ret && (msg0.type() == RA_MSG0)) {
                s = this->handleMSG0(msg0);
                res.push_back(to_string(RA_MSG0));
            }
        }
        break;
        case RA_MSG1: {
            Messages::MessageMSG1 msg1;
            ret = msg1.ParseFromString(v);
            if (ret && (msg1.type() == RA_MSG1)) {
                s = this->handleMSG1(msg1);
                res.push_back(to_string(RA_MSG2));
            }
        }
        break;
        case RA_MSG3: {
            Messages::MessageMSG3 msg3;
            ret = msg3.ParseFromString(v);
            if (ret && (msg3.type() == RA_MSG3)) {
                s = this->handleMSG3(msg3);
                res.push_back(to_string(RA_ATT_RESULT));
            }
        }
        break;
        case RA_PSI_SLAT: {
            Messages::MessagePsiSalt att_ok_msg;
            ret = att_ok_msg.ParseFromString(v);
            if (ret) {
                if (att_ok_msg.type() == RA_PSI_SLAT) {
                    s = this->handleAppAttOk(att_ok_msg);
                    res.push_back(to_string(RA_PSI_HASHDATA));
                }
            }
        }
        break;
        case RA_PSI_RESULT: {
            Messages::MessagePsiResult msg;
            ret = msg.ParseFromString(v);
            if (ret) {
                if (msg.type() == RA_PSI_RESULT) {
                    if (msg.state() == 1) {
                        //no intersect result, send finished again.
                        sleep(1);
                    }
                    bool finished = false;
                    s = this->handleHashData(msg, &finished);
                    if (finished) {
                        res.push_back(to_string(RA_PSI_HASHDATA_FINISHED));
                    } else {
                        res.push_back(to_string(RA_PSI_HASHDATA));
                    }
                }
            }
        }
        break;
        case RA_PSI_INTERSECT: {
            Messages::MessagePsiIntersect inter_msg;
            ret = inter_msg.ParseFromString(v);
            if (ret) {
                if (inter_msg.type() == RA_PSI_INTERSECT) {
                    s = this->handleHashIntersect(inter_msg);
                }
            }
        }
        break;
        default:
            Log("Unknown type: %d", type, log::error);
            break;
        }

        res.push_back(s);
    } else { 	//after handshake
        res.push_back(to_string(RA_VERIFICATION));
        res.push_back(this->prepareVerificationRequest());
    }

    return res;
}