measure_module/parkspace_allocation/parkspace_allocation_communicator.cpp

//
// Created by zx on 2020/6/18.
//

#include "parkspace_allocation_communicator.h"

Parkspace_allocation_communicator::Parkspace_allocation_communicator()
{
}

Parkspace_allocation_communicator::~Parkspace_allocation_communicator()
{
}

//************************************* 公有函数 ****************************************
//外部调用发送分配车位结果
Error_manager Parkspace_allocation_communicator::send_response(Communication_message *message)
{
    return encapsulate_msg(message);
}

//外部调用更新所有车位信息/初始化所有车位
Error_manager Parkspace_allocation_communicator::update_parkspace_status(message::Parkspace_allocation_status_msg status_msg)
{
    std::lock_guard<std::mutex> lck(m_status_mutex);
    m_parkspace_status_msg.CopyFrom(status_msg);
    return SUCCESS;
}

//外部调用更新单一车位信息
Error_manager Parkspace_allocation_communicator::update_parkspace_status(int parkspace_id, message::Parkspace_info parkspace_info)
{
    std::lock_guard<std::mutex> lck(m_status_mutex);
    if(m_parkspace_status_msg.parkspace_info_size() >= parkspace_id)
    {
        m_parkspace_status_msg.mutable_parkspace_info(parkspace_id-1)->CopyFrom(parkspace_info);
    }
    return SUCCESS;
}

//外部调用获取当前车位状态消息
message::Parkspace_allocation_status_msg Parkspace_allocation_communicator::get_status()
{
    std::lock_guard<std::mutex> lck(m_status_mutex);
    message::Parkspace_allocation_status_msg parkspace_status_msg;
    parkspace_status_msg.CopyFrom(m_parkspace_status_msg);
    return parkspace_status_msg;
}

//************************************* 内部函数 ****************************************
//封装反馈消息自动发送
Error_manager Parkspace_allocation_communicator::encapsulate_msg(Communication_message *message)
{
    if (message == nullptr)
    {
        return Error_manager(POINTER_IS_NULL, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message null pointer");
    }
    //针对待发送的不同反馈消息，分别进行校核
    switch(message->get_message_type())
    {
        case Communication_message::eParkspace_allocation_response_msg:
        {
            message::Parkspace_allocation_response_msg response;
            bool result = response.ParseFromString(message->get_message_buf());
            //可增加待发送分配车位反馈消息校核
            break;
        }
        case Communication_message::eParkspace_search_response_msg:
        {
            break;
        }
        case Communication_message::eParkspace_release_response_msg:
        {
            break;
        }
        default:
            return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message response type error");
    }

    //发送请求
    return Communication_socket_base::encapsulate_msg(message);
}

//重载执行消息，父类线程通过check_msg接收到车位分配请求后调用，解析内容并进行相应处理
Error_manager Parkspace_allocation_communicator::execute_msg(Communication_message *p_msg)
{
    if (p_msg == nullptr)
        return Error_manager(POINTER_IS_NULL, CRITICAL_ERROR, "parkspace allocation response msg pointer is null");
    //车位分配request消息
    switch (p_msg->get_message_type())
    {
        ///测量结果反馈消息
        case Communication_message::eParkspace_allocation_request_msg:
        {
            message::Parkspace_allocation_request_msg request;
            request.ParseFromString(p_msg->get_message_buf());
            std::cout<<"allocation request, car license: "<<request.car_info().license()<<std::endl;

            //根据请求的信息反馈分配的车位,并封装发送
            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
            message::Parkspace_allocation_response_msg response_msg;
            message::Base_info t_response_header;
            message::Error_manager t_error;
            message::Parkspace_info t_allocated_space;
            t_response_header.set_msg_type(message::Message_type::eParkspace_allocation_response_msg);
            t_response_header.set_timeout_ms(1000);
            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
            t_response_header.set_receiver(message::Communicator::eMain);
            if(m_parkspace_status_msg.parkspace_info_size()>0)
            {
                t_error.set_error_code(0);
                t_error.set_error_level(message::Error_level::NORMAL);
                t_allocated_space.CopyFrom(m_parkspace_status_msg.parkspace_info(0));
            } else{
                t_error.set_error_code(1);
                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
            }
            response_msg.mutable_base_info()->CopyFrom(t_response_header);
            response_msg.set_command_id(request.command_id());
            response_msg.mutable_error_manager()->CopyFrom(t_error);
            response_msg.mutable_allocated_space_info()->CopyFrom(t_allocated_space);
            Communication_message* response=new Communication_message();
            response->reset(t_response_header, response_msg.SerializeAsString());
            return send_response(response);
            // return SUCCESS;
        }
        case Communication_message::eParkspace_search_request_msg:
        {
            message::Parkspace_search_request_msg request;
            request.ParseFromString(p_msg->get_message_buf());
            std::cout<<"search request, car license: "<<request.car_info().license()<<std::endl;

            //根据车辆凭证信息查询车辆位置
            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
            message::Parkspace_search_response_msg response_msg;
            message::Base_info t_response_header;
            message::Error_manager t_error;
            message::Parkspace_info t_car_position;
            t_response_header.set_msg_type(message::Message_type::eParkspace_search_response_msg);
            t_response_header.set_timeout_ms(1000);
            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
            t_response_header.set_receiver(message::Communicator::eMain);
            if (m_parkspace_status_msg.parkspace_info_size() > 1)
            {
                t_error.set_error_code(0);
                t_error.set_error_level(message::Error_level::NORMAL);
                t_car_position.CopyFrom(m_parkspace_status_msg.parkspace_info(1));
            }
            else
            {
                t_error.set_error_code(1);
                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
            }
            response_msg.mutable_base_info()->CopyFrom(t_response_header);
            response_msg.set_command_id(request.command_id());
            response_msg.mutable_error_manager()->CopyFrom(t_error);
            response_msg.mutable_car_position()->CopyFrom(t_car_position);
            Communication_message* response=new Communication_message();
            response->reset(t_response_header, response_msg.SerializeAsString());
            return send_response(response);
        }
        case Communication_message::eParkspace_release_request_msg:
        {
            message::Parkspace_release_request_msg request;
            request.ParseFromString(p_msg->get_message_buf());
            std::cout<<"release request, parkspace id: "<<request.release_space_info().parkspace_id()<<std::endl;

            //根据车位信息定位待释放车位位置，车辆凭证号用于校验
            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
            message::Parkspace_release_response_msg response_msg;
            message::Base_info t_response_header;
            message::Error_manager t_error;
            t_response_header.set_msg_type(message::Message_type::eParkspace_release_response_msg);
            t_response_header.set_timeout_ms(1000);
            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
            t_response_header.set_receiver(message::Communicator::eMain);
            if (m_parkspace_status_msg.parkspace_info_size() > 0)
            {
                t_error.set_error_code(0);
                t_error.set_error_level(message::Error_level::NORMAL);
            }
            else
            {
                t_error.set_error_code(1);
                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
            }
            response_msg.mutable_base_info()->CopyFrom(t_response_header);
            response_msg.set_command_id(request.command_id());
            response_msg.mutable_error_manager()->CopyFrom(t_error);
            response_msg.mutable_release_space_info()->CopyFrom(request.release_space_info());
            Communication_message* response=new Communication_message();
            response->reset(t_response_header, response_msg.SerializeAsString());
            return send_response(response);
        }
    }
    return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "parkspace allocation wrong request type");
}

//检查消息是否应由本模块接收
//本模块接收车位分配请求、车位查询请求与车位释放请求
Error_manager Parkspace_allocation_communicator::check_msg(Communication_message* p_msg)
{
    //通过 p_msg->get_message_type() 和 p_msg->get_receiver() 判断这条消息是不是车位请求消息.
    if(p_msg->get_receiver() == Communication_message::Communicator::eParkspace_allocator)
    {
        switch(p_msg->get_message_type())
        {
            case Communication_message::Message_type::eParkspace_allocation_request_msg:
                return Error_code::SUCCESS;
            case Communication_message::Message_type::eParkspace_search_request_msg:
                return Error_code::SUCCESS;
            case Communication_message::Message_type::eParkspace_release_request_msg:
                return Error_code::SUCCESS;
            default:
                return Error_code::INVALID_MESSAGE;
        }
    }
}

Error_manager Parkspace_allocation_communicator::check_executer(Communication_message*  p_msg)
{
    //检查对应模块的状态, 判断是否可以处理这条消息
	//同时也要判断是否超时, 超时返回 COMMUNICATION_ANALYSIS_TIME_OUT
	//如果处理器正在忙别的, 那么返回 COMMUNICATION_EXCUTER_IS_BUSY

	if ( p_msg->is_over_time() )
	{
		std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
		std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
		std::cout << "COMMUNICATION_ANALYSIS_TIME_OUT , " << std::endl;
		return Error_code::COMMUNICATION_ANALYSIS_TIME_OUT;
	}
	else
	{
		bool executer_is_ready = true;
		//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 找到处理模块的实例对象, 查询执行人是否可以处理这条消息
		//这里子类重载时, 增加判断逻辑, 以后再写.
		// std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
		// std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;

		if ( executer_is_ready )
		{
			// std::cout << "executer_is_ready , " << std::endl;
			return Error_code::SUCCESS;
		}
		else
		{
			std::cout << "executer_is_busy , " << std::endl;
			return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
		}
	}

	return Error_code::SUCCESS;
}

//重载心跳与车位状态发送函数
Error_manager Parkspace_allocation_communicator::encapsulate_send_data()
{
    return Error_code::SUCCESS;
    std::lock_guard<std::mutex> lck(m_status_mutex);
    //车位信息消息赋值
	message::Parkspace_allocation_status_msg t_parkspace_status_msg;
    t_parkspace_status_msg.CopyFrom(m_parkspace_status_msg);
    message::Base_info t_base_info;
    message::Error_manager t_error;
	t_base_info.set_msg_type(message::Message_type::eParkspace_allocation_status_msg);
	t_base_info.set_timeout_ms(5000);
	t_base_info.set_sender(message::Communicator::eParkspace_allocator);
	t_base_info.set_receiver(message::Communicator::eMain);
    t_error.set_error_code(0);
    t_parkspace_status_msg.mutable_base_info()->CopyFrom(t_base_info);
    t_parkspace_status_msg.mutable_error_manager()->CopyFrom(t_error);

	Communication_message* tp_msg = new Communication_message(t_parkspace_status_msg.SerializeAsString());
    //重置消息，填入头信息
    tp_msg->reset(t_base_info, tp_msg->get_message_buf());
	bool is_push = m_send_data_list.push(tp_msg);
	if ( is_push == false )
	{
		delete(tp_msg);
		tp_msg = NULL;
		return Error_manager(Error_code::CONTAINER_IS_TERMINATE, Error_level::MINOR_ERROR,
							 " Parkspace_allocation_communicator::send status error ");
	}
	return Error_code::SUCCESS;
}