Terminal_process_CT/system/StoreProcessTask.cpp

//
// Created by zx on 2020/7/7.
//

#include <parkspace_excutor.h>
#include <dispatch_message.pb.h>
#include "dispatch_excutor.h"
#include "StoreProcessTask.h"
#include "process_message.pb.h"
#include "command_manager.h"
#include "command_accepter.h"
#include "exception_solver.h"
#include "uniq_key.h"

StoreProcessTask::StoreProcessTask(unsigned int terminor_id,message::Car_info car_info)
    :Process_task(terminor_id,car_info)
{
}

StoreProcessTask::~StoreProcessTask()
{
    Exception_solver::get_instance_pointer()->delete_task_cancel_condition(m_car_info.license());

}

Error_manager StoreProcessTask::init_task(message::Locate_information locate_info)
{
    reset_msg();

    m_locate_info=locate_info;

    //添加当前流程的任务取消标志位到异常处理模块
    m_cancel_condition.reset(false, false, false);
    Error_manager code=Exception_solver::get_instance_pointer()->add_task_cancel_condition(m_car_info.license(),this);
    if(code!=SUCCESS)
        return code;

    //初始化进度状态消息基本信息
    message::Base_info base_info;
    base_info.set_msg_type(message::eStoring_process_statu_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eEmpty);
    m_process_msg.mutable_base_info()->CopyFrom(base_info);
    m_process_msg.set_terminal_id(m_terminor_id);
    m_process_msg.set_license(m_car_info.license());

    m_current_step_type=message::eAlloc_step;
    ///创建状态发布线程
    if(m_publish_statu_thread== nullptr)
    {
        m_publish_exit_condition.reset(false, false, false);
        m_publish_statu_thread=new std::thread(publish_thread_func,this);
    }

    return SUCCESS;

}

Error_manager StoreProcessTask::locate_step() {
    Error_manager code;
    //检查测量模块状态
    code=Measure_excutor::get_instance_pointer()->check_statu(m_terminor_id);
    if(code!=SUCCESS)
        return code;

    message::Base_info base_info;
    base_info.set_msg_type(message::eLocate_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eMeasurer);
    base_info.set_timeout_ms(20000); //测量超时5s
    m_measure_request_msg.mutable_base_info()->CopyFrom(base_info);

    m_measure_request_msg.set_command_key(create_key());
    m_measure_request_msg.set_terminal_id(m_terminor_id);

    code=Measure_excutor::get_instance_pointer()->locate_request(m_measure_request_msg,
            m_measure_response_msg,m_cancel_condition);
    if(code!=SUCCESS)
        return code;

    if(m_measure_response_msg.error_manager().error_code()==0) {
        return SUCCESS;
    }
    else {
        Error_code t_code=(Error_code)m_measure_response_msg.error_manager().error_code();
        Error_level t_level=(Error_level)m_measure_response_msg.error_manager().error_level();
        return Error_manager(t_code, t_level, m_measure_response_msg.error_manager().error_description().c_str());
    }

}

/*
     * 回退定位
     */
Error_manager StoreProcessTask::back_locate_step()
{
    m_measure_request_msg=message::Measure_request_msg();
    m_measure_response_msg=message::Measure_response_msg();
    int k=rand()%5;
    if(k==0)
        return Error_manager(ERROR,CRITICAL_ERROR,"回退测量对比失败");
    return SUCCESS;
}

/*
     * 检验结果
     */
Error_manager StoreProcessTask::compare_step()
{
    return SUCCESS;
}
/*
 * 回退检验
 */
Error_manager StoreProcessTask::back_compare_step()
{
    int k=rand()%5;
    if(k==0)
        return Error_manager(ERROR,CRITICAL_ERROR,"回退检验对比失败");
    return SUCCESS;
}

/*
* 调度
*/
Error_manager StoreProcessTask::dispatch_step()
{
    Error_manager code;
    /*
     * 判断调度所需的数据是否都正常
     */
    //1,测量信息是否存在
    if(m_measure_response_msg.has_base_info()== false
        ||m_measure_response_msg.has_locate_information()==false
        ||m_parcspace_alloc_response_msg.has_base_info()== false
        ||m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
    {
        return Error_manager(ERROR,MAJOR_ERROR,"调度所需的前置数据(测量,车位)不存在");
    }

    //2,判断调度节点状态
    code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(m_terminor_id);
    if(code!=SUCCESS)
        return code;

    message::Base_info base_info;
    base_info.set_msg_type(message::eDispatch_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eDispatch);
    base_info.set_timeout_ms(1000*15); //超时15s
    m_dispatch_request_msg.mutable_base_info()->CopyFrom(base_info);

    std::string key=create_key();
    m_dispatch_request_msg.set_command_key(key);
    m_dispatch_request_msg.set_terminal_id(m_terminor_id);
    m_dispatch_request_msg.set_dispatch_motion_direction(message::E_STORE_CAR);
    m_dispatch_request_msg.set_parkspace_id(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id());

    code=Dispatch_excutor::get_instance_pointer()->dispatch_request(m_dispatch_request_msg,
            m_dispatch_response_msg,m_cancel_condition);
    if(code!=SUCCESS)
        return code;

    if(m_dispatch_response_msg.error_manager().error_code()==0) {
        return SUCCESS;
    }
    else
    {
        Error_code t_code=(Error_code)m_dispatch_response_msg.error_manager().error_code();
        Error_level t_level=(Error_level)m_dispatch_response_msg.error_manager().error_level();
        return Error_manager(t_code,t_level,"dispatch response error_code error");
    }
}

/*
     * 回退调度
     */
Error_manager StoreProcessTask::back_dispatch_step()
{
    //reset 调度请求数据
    m_dispatch_request_msg=message::Dispatch_request_msg();
    m_dispatch_response_msg=message::Dispatch_response_msg();


    return SUCCESS;
}

/*
     * 分配车位
     */
Error_manager StoreProcessTask::alloc_space_step()
{

    message::Base_info base_info_response;
    base_info_response.set_msg_type(message::eStore_command_response_msg);
    base_info_response.set_sender(message::eMain);
    base_info_response.set_receiver(message::eTerminor);
    m_command_response_msg.mutable_base_info()->CopyFrom(base_info_response);
    m_command_response_msg.set_terminal_id(m_terminor_id);

    if(Command_manager::get_instance_pointer()->is_paused()==true)
    {
        return Error_manager(PAUSE, MINOR_ERROR, "系统已急停");
    }
    //
    message::Entrance_statu statu=Command_manager::get_instance_pointer()->entrance_statu(m_terminor_id);
    if(statu.has_paused()==false) {
        return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
    }
    if(statu.paused()==true)
    {
        return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
    }

    /*
     * 检查是否有测量数据
     */
    if(m_locate_info.has_locate_height()==false||m_locate_info.has_locate_width()==false)
    {
        return Error_manager(FAILED,MINOR_ERROR,"停车请求缺少车辆高度和宽度信息");
    }
    /*
     * 检查车位管理模块是否正常
     */
    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
    if(code!=SUCCESS)
    {
        return code;
    }

    //发送分配请求
    message::Base_info base_info_request;
    base_info_request.set_msg_type(message::eParkspace_allocation_request_msg);
    base_info_request.set_sender(message::eMain);
    base_info_request.set_receiver(message::eParkspace);
    base_info_request.set_timeout_ms(5000); //超时1s
    m_alloc_request_msg.mutable_base_info()->CopyFrom(base_info_request);

    m_alloc_request_msg.mutable_car_info()->CopyFrom(m_car_info);

    m_alloc_request_msg.set_command_key(create_key());
    m_alloc_request_msg.set_terminal_id(m_terminor_id);

    code=Parkspace_excutor::get_instance_pointer()->alloc_request(m_alloc_request_msg,
            m_parcspace_alloc_response_msg,m_cancel_condition);

    if(code!=SUCCESS)
    {
        return code;
    }

    if(m_parcspace_alloc_response_msg.error_manager().error_code()==0)
    {
        message::Car_info alloc_car_info=m_parcspace_alloc_response_msg.allocated_space_info().car_info();
        if(alloc_car_info.license()!=m_car_info.license())
        {
            return Error_manager(ERROR,MINOR_ERROR,"分配车位反馈的车辆信息不匹配");
        }
        return SUCCESS;
    }
    else
    {
        Error_code  t_code=(Error_code)m_parcspace_alloc_response_msg.error_manager().error_code();
        Error_level t_level=(Error_level)m_parcspace_alloc_response_msg.error_manager().error_level();
        return Error_manager(t_code,t_level,"分配车位反馈结果错误");
    }
}

/*
 * 车位占用确认
 */
Error_manager StoreProcessTask::confirm_space_step()
{
    /*
     * 检查车位管理模块是否正常
     */
    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
    if(code!=SUCCESS)
        return code;

    message::Parkspace_confirm_alloc_request_msg request;
    message::Base_info base_info;
    base_info.set_msg_type(message::eParkspace_confirm_alloc_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eParkspace);
    base_info.set_timeout_ms(5000); //测量超时1s
    request.mutable_base_info()->CopyFrom(base_info);

    message::Parkspace_info space_info=m_parcspace_alloc_response_msg.allocated_space_info();
    request.mutable_confirm_space_info()->CopyFrom(space_info);
    request.set_command_key(create_key());

    message::Parkspace_confirm_alloc_response_msg confirm_response;
    code=Parkspace_excutor::get_instance_pointer()->confirm_request(request,confirm_response,m_cancel_condition);
    if(code!=SUCCESS)
        return code;

    if(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()!=
            confirm_response.confirm_alloc_space_info().parkspace_id())
    {
        return Error_manager(ERROR,MINOR_ERROR,"占用车位与分配车位不一致");
    }

    if(confirm_response.error_manager().error_code()==0) {
        /*LOG(INFO)<<"停车流程正常,确认占用车位成功,停车终端:"<<m_terminor_id
                    <<", 指令id:"<<m_command_info.place()+m_command_info.time()
                    <<", 车位楼层:"<<confirm_response.confirm_alloc_space_info().floor()
                    <<", 车位序号:"<<confirm_response.confirm_alloc_space_info().index()
                    <<", 车牌号:"<<confirm_response.confirm_alloc_space_info().car_info().license();*/
        return SUCCESS;
    }
    else
    {
        Error_code t_code=(Error_code)confirm_response.error_manager().error_code();
        Error_level t_level=(Error_level)confirm_response.error_manager().error_level();
        return Error_manager(t_code,t_level,"parkspace confirm response error_code error");
    }
}


/*
 * 回退车位分配
 */
Error_manager StoreProcessTask::back_alloc_space_step()
{
    int k=rand()%5;
    if(k==0)
        return Error_manager(ERROR,CRITICAL_ERROR,"回退车位分配失败");
    /*
    * 检查是否曾经分配过车位
    */
    if(m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
    {
        return Error_manager(FAILED,CRITICAL_ERROR," parkspace release request without space info");
    }

    /*
     * 检查车位管理模块是否正常
     */
    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
    if(code!=SUCCESS)
        return Error_manager(code.get_error_code(),CRITICAL_ERROR,code.get_error_description());

    message::Parkspace_release_request_msg request;
    message::Base_info base_info;
    base_info.set_msg_type(message::eParkspace_release_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eParkspace);
    base_info.set_timeout_ms(5000); //测量超时1s
    request.mutable_base_info()->CopyFrom(base_info);

    message::Parkspace_info space_info=m_parcspace_alloc_response_msg.allocated_space_info();
    request.mutable_release_space_info()->CopyFrom(space_info);
    request.set_command_key(create_key());

    message::Parkspace_release_response_msg release_response;
    code=Parkspace_excutor::get_instance_pointer()->release_request(request,release_response,m_cancel_condition);
    if(code!=SUCCESS)
        return Error_manager(code.get_error_code(),CRITICAL_ERROR,code.get_error_description());

    if(release_response.error_manager().error_code()==0) {
        /*LOG(WARNING)<<"停车流程异常,释放车位成功,停车终端:"<<m_terminor_id
                 <<", 指令id:"<<m_command_info.place()+m_command_info.time()
                 <<", 车位楼层:"<<m_parcspace_alloc_response_msg.allocated_space_info().floor()
                 <<", 车位序号:"<<m_parcspace_alloc_response_msg.allocated_space_info().index()
                 <<", 车牌号:"<<m_parcspace_alloc_response_msg.allocated_space_info().car_info().license();*/

        m_alloc_request_msg=message::Parkspace_allocation_request_msg();
        m_parcspace_alloc_response_msg=message::Parkspace_allocation_response_msg();
        return SUCCESS;
    }
    else
    {
        Error_code t_code=(Error_code)release_response.error_manager().error_code();
        Error_level t_level=(Error_level)release_response.error_manager().error_level();
        return Error_manager(t_code,CRITICAL_ERROR,"back alloc response error_code error");
    }
}

/*
     * 控制流程到下一步
     */
Error_manager StoreProcessTask::next_step()
{
    if(m_current_step_statu==message::eWaiting || m_current_step_statu== message::eWorking)
        return Error_manager(ERROR,MINOR_ERROR,"当前状态禁止改变步骤类型");
    switch (m_current_step_type)
    {
        case message::eAlloc_step:
            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eMeasure_step:message::eBackComplete;
            break;
        case message::eMeasure_step:
            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eCompare_step:message::eBackAlloc_step;
            break;
        case message::eCompare_step:
            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eDispatch_step:message::eBackMeasure_step;
            break;
        case message::eDispatch_step:
            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eConfirm_step:message::eBack_compare_step;
            break;
        case message::eConfirm_step:
            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eComplete:message::eBackDispatch_step;
            break;
        case message::eComplete:
            break;
        case message::eBackDispatch_step:
            m_current_step_type=message::eBack_compare_step;
            break;
        case message::eBack_compare_step:
            m_current_step_type=message::eBackMeasure_step;
            break;
        case message::eBackMeasure_step:
            m_current_step_type=message::eBackAlloc_step;
            break;
        case message::eBackAlloc_step:
            m_current_step_type=message::eBackComplete;
            break;
        case message::eBackComplete:
            break;
    }
    return SUCCESS;
}

/*
 * 流程函数
 */
void StoreProcessTask::Main()
{
    /*
     * 外部已经分配好车位,进入到此流程说明车位已经分配好, 存放在 m_parcspace_alloc_response_msg
     */
    Error_manager code;

    //开始执行停车指令
    while(is_canceled()==false)
    {
        //第一步分配车位
        if(m_current_step_type == message::eAlloc_step)
        {
            updata_step_statu(message::eWorking);
            code=alloc_space_step();
            //发送反馈
            message::Error_manager error_msg;
            error_msg.set_error_code(code.get_error_code());
            error_msg.set_error_description(code.get_error_description());
            m_command_response_msg.mutable_code()->CopyFrom(error_msg);
            Communication_message msg;
            msg.reset(m_command_response_msg.base_info(),m_command_response_msg.SerializeAsString());
            Message_communicator::get_instance_pointer()->send_msg(&msg);

            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            LOG_IF(ERROR, code != SUCCESS) << "分配失败:" <<m_car_info.license()<< code.get_error_description();
        }

        //第二步,测量
        if (m_current_step_type ==  message::eMeasure_step)
        {
            //开始定位
            updata_step_statu(message::eWorking);
            code = locate_step();
            usleep(1000 * 1000 );
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);

            LOG_IF(ERROR, code != SUCCESS) << "测量失败:" <<m_car_info.license()<< code.get_error_description();
        }
        if(m_current_step_type== message::eCompare_step)
        {
            updata_step_statu(message::eWorking);
            code=compare_step();
            usleep(500*1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);

            LOG_IF(ERROR, code != SUCCESS) << "检验失败:"<<m_car_info.license() << code.get_error_description();
        }
        //第二步,调度
        if (m_current_step_type ==  message::eDispatch_step)
        {
            //开始调度
            updata_step_statu(message::eWorking);
            code = dispatch_step();
            usleep(1000 * 2000 );
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            LOG_IF(ERROR, code != SUCCESS) << "调度失败:"<<m_car_info.license() << code.get_error_description();
        }
        //第三步,占据车位
        if (m_current_step_type ==  message::eConfirm_step)
        {
            updata_step_statu(message::eWorking);
            code = confirm_space_step();
            usleep(1000 * 1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            LOG_IF(ERROR, code != SUCCESS) << "终端号:" << m_terminor_id << "停车流程:" << code.get_error_description() <<
                                           " 车位id :"
                                           << m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()
                                           << ",车牌:" << m_car_info.license()<<code.to_string();
        }
        //第四步,完成,退出循环
        if (m_current_step_type ==  message::eComplete)
        {
            //流程结束前,保证至少发送一次流程完成状态
            updata_step_statu(message::eFinished);
            break;
        }

        //回退confirm  ------------------------------------华丽的分割线------------------------------------------

        if (m_current_step_type ==  message::eBackConfirm_step)
        {
            updata_step_statu(message::eWorking);
            usleep(1000*1000);
            updata_step_statu(message::eFinished);

        }
        if(m_current_step_type== message::eBackDispatch_step)
        {
            updata_step_statu(message::eWorking);
            code=back_dispatch_step();
            usleep(1000*1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            if(code.get_error_level()>=MAJOR_ERROR)
            {
                //提升错误等级为四级
                LOG(ERROR)<<" 回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                Exception_solver::get_instance_pointer()->solve_exception(code,this);
                continue;
            }
        }

        if(m_current_step_type== message::eBack_compare_step)
        {
            updata_step_statu(message::eWorking);
            code=back_compare_step();
            usleep(1000*1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            if(code.get_error_level()>=MAJOR_ERROR)
            {
                LOG(ERROR)<<" 回退对比失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                Exception_solver::get_instance_pointer()->solve_exception(code,this);
                LOG(WARNING)<<" 手动处理 结果对比,  继续 ..........车牌:"<<m_car_info.license();
                continue;
            }
        }

        if(m_current_step_type== message::eBackMeasure_step)
        {
            updata_step_statu(message::eWorking);
            code=back_locate_step();
            usleep(1000*1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            if(code.get_error_level()>=MAJOR_ERROR)
            {
                //提升错误等级为四级
                LOG(ERROR)<<" 回退测量失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                Exception_solver::get_instance_pointer()->solve_exception(code,this);
                continue;
            }
        }
        if(m_current_step_type== message::eBackAlloc_step)
        {
            updata_step_statu(message::eWorking);
            code=back_alloc_space_step();
            usleep(1000*1000);
            code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
            if(code.get_error_level()>=MAJOR_ERROR)
            {
                //提升错误等级为四级
                LOG(ERROR)<<" 回退分配车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                Exception_solver::get_instance_pointer()->solve_exception(code,this);
                continue;
            }
        }
        if(m_current_step_type== message::eBackComplete)
        {
            break;
        }
        next_step();
    }

    /*
     * 跳出循环后,判断状态,是否正常结束, 循环跳出状态只有可能是 eBackComplete(异常结束),eComplete(正常结束),任务取消状态
     */
    updata_step_statu(message::eFinished);
    publish_step_status();

    if(m_cancel_condition.wait_for_millisecond(1)==true) {
        LOG(ERROR) << "停车任务被强制取消,车牌号:" << m_car_info.license()
                   << ",  终端号:" << m_terminor_id;
        usleep(1000*200);
        return ;
    }

    if(m_current_step_type== message::eBackComplete)
    {
        //异常结束
        usleep(1000*200);
        LOG(ERROR)<<"异常停车,回退结束"<<"车牌号:"<<m_car_info.license()
            <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
    }
    if(m_current_step_type== message::eComplete)
    {
        //正常结束
        usleep(1000*200);
        LOG(INFO)<<"停车结束,"<<"车牌号:"<<m_car_info.license()
            <<",--------------  终端:"<<m_terminor_id<<"  --------------";
    }
}


void StoreProcessTask::publish_step_status() {
    /*
     * 通过communicator 发布状态
     */
    if (Command_accepter::get_instance_pointer()) {
        std::lock_guard<std::mutex> lock(m_process_msg_lock);
        Command_accepter::get_instance_pointer()->post_process_statu(m_process_msg);
    }
}

/*
     * 根据当前流程状态,并修改状态消息
     */
void StoreProcessTask::updata_step_statu(message::Step_statu statu)
{
    m_current_step_statu=statu;
    std::lock_guard<std::mutex>         lock(m_process_msg_lock);
    switch (m_current_step_type) {
        case  message::eAlloc_step: {
                message::Alloc_space_step_statu alloc_step_statu;
                alloc_step_statu.set_step_statu(statu);
                m_process_msg.mutable_alloc_space_step()->CopyFrom(alloc_step_statu);
            break;
        }
        case  message::eMeasure_step: {
                message::Measure_step_statu measure_step_statu;
                measure_step_statu.set_step_statu(statu);
                measure_step_statu.mutable_locate_info()->CopyFrom(m_locate_info);
                m_process_msg.mutable_measure_step()->CopyFrom(measure_step_statu);
           break;
        }
        case  message::eCompare_step:{
            message::Compare_step_statu     compare_step;
            compare_step.mutable_locate_info_wj()->CopyFrom(m_locate_info);
            compare_step.mutable_locate_info_dj()->CopyFrom(m_measure_response_msg.locate_information());
            compare_step.mutable_locate_info_result()->CopyFrom(m_compare_location_data);
            compare_step.set_step_statu(statu);
            m_process_msg.mutable_compare_step()->CopyFrom(compare_step);
            break;
        }
        case  message::eDispatch_step: {
            message::Dispatch_store_step_statu          dispatch_step_statu;
            dispatch_step_statu.set_step_statu(statu);
            dispatch_step_statu.mutable_locate_info()->CopyFrom(m_locate_info);
            dispatch_step_statu.mutable_space_info()->CopyFrom(m_parcspace_alloc_response_msg.allocated_space_info());
            m_process_msg.mutable_dispatch_step()->CopyFrom(dispatch_step_statu);
            break;
        }
        case  message::eConfirm_step: {
            message::Confirm_space_step_statu           confirm_step_type;
            confirm_step_type.set_step_statu(statu);
            confirm_step_type.mutable_space_info()->CopyFrom(m_parcspace_alloc_response_msg.allocated_space_info());
            m_process_msg.mutable_confirm_space_step()->CopyFrom(confirm_step_type);
            break;
        }
        case  message::eComplete: {
            m_process_msg.set_completed(true);
            break;
        }
        case  message::eBackConfirm_step: {
                message::Back_confirm_space_step_statu back_confirm_step_type;
                back_confirm_step_type.set_step_statu(statu);
                m_process_msg.mutable_back_confirm_step()->CopyFrom(back_confirm_step_type);
            break;
        }
        case  message::eBackDispatch_step: {
            message::Back_dispatch_store_step_statu   back_dispatch_step_statu;
            back_dispatch_step_statu.set_step_statu(statu);
            back_dispatch_step_statu.mutable_space_info()->CopyFrom(m_parcspace_alloc_response_msg.allocated_space_info());
            back_dispatch_step_statu.mutable_locate_info()->CopyFrom(m_compare_location_data);
            m_process_msg.mutable_back_dispatch_step()->CopyFrom(back_dispatch_step_statu);
            break;
        }
        case  message::eBack_compare_step:{
            message::Back_compare_step_statu    back_compare_step_statu;
            back_compare_step_statu.set_step_statu(statu);
            back_compare_step_statu.mutable_locate_info_wj()->CopyFrom(m_locate_info);
            back_compare_step_statu.mutable_locate_info_dj()->CopyFrom(m_measure_response_msg.locate_information());
            back_compare_step_statu.mutable_locate_info_result()->CopyFrom(m_compare_location_data);
            m_process_msg.mutable_back_compare_step()->CopyFrom(back_compare_step_statu);
            break;
        }
        case  message::eBackMeasure_step: {
            message::Back_measure_step_statu        back_measure_step_statu;
            back_measure_step_statu.set_step_statu(statu);
            m_process_msg.mutable_back_measure_step()->CopyFrom(back_measure_step_statu);
            break;
        }
        case  message::eBackAlloc_step: {
            message::Back_alloc_space_step_statu    back_alloc_step_statu;
            back_alloc_step_statu.set_step_statu(statu);
            back_alloc_step_statu.mutable_space_info()->CopyFrom(m_parcspace_alloc_response_msg.allocated_space_info());
            m_process_msg.mutable_back_alloc_space_step()->CopyFrom(back_alloc_step_statu);
            break;
        }
        case  message::eBackComplete: {
            m_process_msg.set_back_completed(true);
            break;
        }
        default:
            break;
    }
}


/*
     * 初始化 接收到的消息
     */
void StoreProcessTask::reset_msg() {


    m_alloc_request_msg = message::Parkspace_allocation_request_msg();
    m_measure_request_msg = message::Measure_request_msg();
    m_dispatch_request_msg = message::Dispatch_request_msg();
    m_confirm_request_msg = message::Parkspace_confirm_alloc_request_msg();

    m_command_response_msg=message::Store_command_response_msg();

    m_locate_info = message::Locate_information();
    m_measure_response_msg = message::Measure_response_msg();         //测量模块的测量数据
    m_parcspace_alloc_response_msg = message::Parkspace_allocation_response_msg(); //分配的车位数据
    m_dispatch_response_msg = message::Dispatch_response_msg();        //调度模块的反馈数据
}