parkspace_manage/parkspace_allocation/parkspace_manager.cpp

/*
 * @Description: 车位分配算法模块，使用单例模式，接收外部请求并通过调用通信块接口发送反馈
 * @Author: yct
 * @Date: 2020-07-10 11:02:40
 * @LastEditTime: 2020-08-06 10:32:28
 * @LastEditors: yct
 */ 

#include "parkspace_manager.h"
#include "parkspace_communicator.h"

Parkspace_manager::Parkspace_manager()
{
}

Parkspace_manager::~Parkspace_manager()
{
	parkspace_manager_uninit();
}

//初始化
Error_manager Parkspace_manager::parkspace_manager_init(int threads_size)
{

    // 初始化任务处理线程池
	m_thread_pool.thread_pool_init(threads_size);
	m_parkspace_manager_satus = eParkspace_manager_normal;
	return Error_code::SUCCESS;
}

//反初始化
Error_manager Parkspace_manager::parkspace_manager_uninit()
{
	m_thread_pool.thread_pool_uninit();
	m_parkspace_manager_satus = eParkspace_manager_unknown;
	return Error_code::SUCCESS;
}

//检查执行者的状态, 判断能否处理这条消息,
Error_manager Parkspace_manager::check_status()
{
	if(get_parkspace_manage_status() != eParkspace_manager_normal)
 	{
		return Error_manager(Error_code::DB_MANAGER_STATUS_ERROR, Error_level::MAJOR_ERROR,
							" Parkspace_manager::check_executer error ");
	}
	return SUCCESS;

}

//处理消息的执行函数
Error_manager Parkspace_manager::execute_msg(Communication_message* p_msg)
{
	if ( p_msg == nullptr )
	{
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							 "  POINTER IS NULL ");
	}
	switch ( p_msg->get_message_type() )
	{
		///车位分配请求消息
        case Communication_message::eParkspace_allocation_request_msg:
        {
            message::Parkspace_allocation_request_msg request;
            bool result = request.ParseFromString(p_msg->get_message_buf());
            LOG(INFO)<<"allocation request, car license: "<<request.car_info().license();
            if(!result)
            {
                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
			    					" message::Parkspace_allocation_request_msg  ParseFromString error ");
            }
//			std::cout<<"分配："<<request.DebugString()<<std::endl;
            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
            m_thread_pool.enqueue(&Parkspace_manager::execute_for_allocate, this,
            request.car_info(), request.terminal_id(), request.command_key());
            return SUCCESS;
        }
        // 车位查询请求消息
        case Communication_message::eParkspace_search_request_msg:
        {
            message::Parkspace_search_request_msg request;
            bool result = request.ParseFromString(p_msg->get_message_buf());
            LOG(INFO)<<"search request, car license: "<<request.car_info().license();
            if(!result)
            {
                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
			    					" message::Parkspace_search_request_msg  ParseFromString error ");
            }
            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
//			std::cout<<"查询："<<request.DebugString()<<std::endl;
			m_thread_pool.enqueue(&Parkspace_manager::execute_for_search, this, request.car_info(), request.command_key());
            return SUCCESS;
        }
        // 车位释放请求消息
        case Communication_message::eParkspace_release_request_msg:
        {
            message::Parkspace_release_request_msg request;
            bool result = request.ParseFromString(p_msg->get_message_buf());
            LOG(INFO)<<"release request  ";
            if(!result)
            {
                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
			    					" message::Parkspace_release_request_msg  ParseFromString error ");
            }
            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
//			std::cout<<"释放："<<request.DebugString()<<std::endl;

			m_thread_pool.enqueue(&Parkspace_manager::execute_for_release, this, request, request.command_key());
            return SUCCESS;
        }
        // 车位手动更新请求消息
        case Communication_message::eParkspace_force_update_request_msg:
        {
            message::Parkspace_force_update_request_msg request;
            bool result = request.ParseFromString(p_msg->get_message_buf());
            LOG(INFO)<<"force update request, parkspace  ";
            if(!result)
            {
                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
			    					" message::Parkspace_force_update_request_msg  ParseFromString error ");
            }
            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
//			std::cout<<"手动："<<request.DebugString()<<std::endl;

			m_thread_pool.enqueue(&Parkspace_manager::execute_for_force_update, this, request, request.command_key());
            return SUCCESS;
        }
        // 车位确认占用请求消息
        case Communication_message::eParkspace_confirm_alloc_request_msg:
        {
            message::Parkspace_confirm_alloc_request_msg request;
            bool result = request.ParseFromString(p_msg->get_message_buf());

            LOG(INFO)<<"confirm alloc request ";
            if(!result)
            {
                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
			    					" message::Parkspace_force_update_request_msg  ParseFromString error ");
            }

			m_thread_pool.enqueue(&Parkspace_manager::execute_for_confirm_alloc, this, request);
            return SUCCESS;
        }
        //车位数据刷新请求
		case Communication_message::eParkspace_refresh_request_msg:
		{
			return send_parkspace_data();
		}
	}
	return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_REQUEST_TYPE_ERROR, Error_level::MINOR_ERROR,
						" fun error ");
}
Error_manager Parkspace_manager::encapsulating_heartbeat_messages()
{
	//封装心跳消息
	Database_controller::Database_controller_status t_database_controller_status;
	Parkspace_manager::Parkspace_manager_satus t_parkspace_manager_satus;
	t_database_controller_status = Database_controller::get_instance_pointer()->get_database_controller_status();
	t_parkspace_manager_satus = Parkspace_manager::get_instance_pointer()->get_parkspace_manage_status();

	//车位信息消息赋值
	message::Parkspace_allocation_status_msg t_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);
	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);

	t_parkspace_status_msg.set_database_controller_status((message::Database_controller_status)t_database_controller_status);
	t_parkspace_status_msg.set_parkspace_manager_satus((message::Parkspace_manager_satus)t_parkspace_manager_satus);


	message::Parkspace_allocation_data_msg parkspaceAllocationDataMsg;
	int t_min_parkspace_size;
	int t_medium_parkspace_size;
	int t_large_parkspace_size;
	int t_total_parkspace_size;
	m_parkspace_operating_function.get_specify_the_type_parkspace_info(parkspaceAllocationDataMsg,message::Parkspace_type::MIN_PARKINGSPACE);
	t_min_parkspace_size = parkspaceAllocationDataMsg.parkspace_info_ex_size();
	t_parkspace_status_msg.set_small_parkspace_remaining_number(t_min_parkspace_size);
	parkspaceAllocationDataMsg.clear_parkspace_info_ex();

	m_parkspace_operating_function.get_specify_the_type_parkspace_info(parkspaceAllocationDataMsg,message::Parkspace_type::MID_PARKINGSPACE);
	t_medium_parkspace_size = parkspaceAllocationDataMsg.parkspace_info_ex_size();
	t_parkspace_status_msg.set_medium_parkspace_remaining_number(t_medium_parkspace_size);
	parkspaceAllocationDataMsg.clear_parkspace_info_ex();

	m_parkspace_operating_function.get_specify_the_type_parkspace_info(parkspaceAllocationDataMsg,message::Parkspace_type::BIG_PARKINGSPACE);
	t_large_parkspace_size = parkspaceAllocationDataMsg.parkspace_info_ex_size();
	t_parkspace_status_msg.set_large_parkspace_remaining_number(t_large_parkspace_size);
	parkspaceAllocationDataMsg.clear_parkspace_info_ex();

	t_total_parkspace_size = t_min_parkspace_size + t_medium_parkspace_size + t_large_parkspace_size;
	t_parkspace_status_msg.set_total_parkspace_remaining_number(t_total_parkspace_size);
	LOG(INFO) << t_parkspace_status_msg.DebugString()<< this;
	return Parkspace_communicator::get_instance_references().encapsulate_msg(t_parkspace_status_msg.SerializeAsString());


}
//判断是否为待机，如果已经准备好，则可以执行任务。
bool Parkspace_manager::is_ready()
{
	if ( m_parkspace_manager_satus == eParkspace_manager_normal && m_thread_pool.thread_is_full_load() == false )
	{
	    return true;
	}
	else
	{
		return false;
	}
}

Parkspace_manager::Parkspace_manager_satus Parkspace_manager::get_parkspace_manage_status()
{
	return m_parkspace_manager_satus;
}

// 检查车辆是否已存在，通常分配前调用
bool Parkspace_manager::check_car_existence(std::string license)
{
	message::Parkspace_info parkspaceInfo;
	//获取车辆状态
	Error_manager error=m_parkspace_operating_function.query_one_parkspace_with_license(license,parkspaceInfo);




	//如果车辆处于停车中或者已入库  则车辆已存在
	if(!parkspaceInfo.has_car_info())
	{
		return false;
	}
	return true;
}
Error_manager Parkspace_manager::send_parkspace_data()
{
	message::Parkspace_allocation_data_msg all_parkspace_data;
	Error_manager t_error=m_parkspace_operating_function.get_all_parkspace_info(all_parkspace_data);
	if(t_error != SUCCESS)
	{
		return t_error;
	}
	message::Base_info t_base_info;
	message::Error_manager error;
	t_base_info.set_msg_type(message::Message_type::eParkspace_allocation_data_msg);
	t_base_info.set_timeout_ms(5000);
	t_base_info.set_sender(message::Communicator::eParkspace);
	t_base_info.set_receiver(message::Communicator::eMain);
	all_parkspace_data.mutable_base_info()->CopyFrom(t_base_info);
	error.set_error_code(0);
	all_parkspace_data.mutable_error_manager()->CopyFrom(error);

	return Parkspace_communicator::get_instance_references().encapsulate_msg(all_parkspace_data.SerializeAsString());
}
//
//找到一个最优车位---方案二
//找左侧车位
Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::Parkspace_info &parkspace_info,message::Car_info car_info,int terminal_id)
{
	//车辆高大于1550mm分在四楼以下，小于1550mm分在四楼以上
	/*
	 * K=j%15
	 * P=i%6
	 * S=15*d-(j%15)*(2*d-1)+[6*d-(i%6)(2*d-1)]*W    W>1
	 */
	float time_min=0;
	int parkingspace_index_id=-1;
	//找左侧车位
	//如果是小车 （低于1.55米属于小车）
	if ( car_info.car_height() <= MIN_CAR_HIGH )
	{
		//获取所有小型车位信息
		message::Parkspace_allocation_data_msg all_min_parkspace_data;
		Error_manager t_error = m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_min_parkspace_data, message::Parkspace_type::MIN_PARKINGSPACE);
		if (t_error != SUCCESS)
		{
			return t_error;
		}
		//遍历所有小型车位
		int i = 0;
		while (i < all_min_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_min_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();
			//筛选出小型车位的中间部分（第一优先级）的空车位
			if (t_parkspace_id % 15 >= 4 && t_parkspace_id % 15 <= 12
				&& all_min_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
			{

				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time = (terminal_id+2) * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
							 (all_min_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
							 (t_parkspace_id % 15 ) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_width() / MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
				if (time_min == 0)
				{
					time_min = time;
					parkingspace_index_id = i;
				}
				else
				{
					if ( time<time_min )
					{
						time_min=time;
						parkingspace_index_id=i;
					}
				}
				std::cout << " ------left-------"  << std::endl;
				std::cout << " time = " << time;
				std::cout << "              time_min = " << time_min;
				std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
			}
			++i;
		}
		//判断小车车位中间部分(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{

			parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::LEFT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找小车车位第二优先级 （侧边）
			int i = 0;
			while (i < all_min_parkspace_data.parkspace_info_ex_size())
			{
				int t_parkspace_id=all_min_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

				if ( (t_parkspace_id % 15 >= 1 && t_parkspace_id % 15 <= 3 || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
					&& all_min_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time = (terminal_id+2) * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
								 (all_min_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 (t_parkspace_id % 15 == 0?15:t_parkspace_id % 15) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_width() / MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if (time_min == 0)
					{
						time_min = time;
						parkingspace_index_id = i;
					}
					else
					{
						if ( time < time_min )
						{
							time_min = time;
							parkingspace_index_id = i;
						}
					}
					std::cout << " ------left-------"  << std::endl;
					std::cout << " time = " << time ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				++i;
			}
			//判断小车车位侧边部分(第二优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info_ex(parkingspace_index_id));
				parkspace_info.set_path_estimate_time(time_min);
				parkspace_info.set_parkspace_path(message::LEFT_PATH);
				parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
				return Error_code::SUCCESS;
			}
		}
	}
	if ( car_info.car_height() <= MID_CAR_HIGH )
	{
		//找中型车位
		//获取中型车位
		message::Parkspace_allocation_data_msg all_mid_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_mid_parkspace_data,message::Parkspace_type::MID_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while(i<all_mid_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

			//如果是六楼的中型车位的中间部分（第一优先级）
			if ( t_parkspace_id >=64 && t_parkspace_id <= 72
				 && all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time=(terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
						   (all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							(t_parkspace_id % 15)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
				if ( time_min == 0 )
				{
					time_min=time;
					parkingspace_index_id=i;

				}
				else
				{
					if ( time<time_min )
					{
						time_min=time;
						parkingspace_index_id=i;
					}
				}
				std::cout << " ------left-------"  << std::endl;
				std::cout << " time = " << time;
				std::cout << "              time_min = " << time_min;
				std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
			}
			++i;
		}
		//判断中型车位的中间部分(第一优先级)是否有找到合适的空车位   如果找到了 直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::LEFT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
		    //如果没找到则找侧边中型车位（第二优先级）
			int i=0;
			while(i<all_mid_parkspace_data.parkspace_info_ex_size())
			{
				int t_parkspace_id=all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

				//如果是六楼的中型车位的侧边（第二优先级）
				if ( (t_parkspace_id >=61 && t_parkspace_id <= 63 || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
					 && all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
								(t_parkspace_id % 15 == 0?15:t_parkspace_id % 15)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if ( time_min == 0 )
					{
						time_min=time;
						parkingspace_index_id=i;

					}
					else
					{
						if ( time<time_min )
						{
							time_min=time;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------left-------"  << std::endl;
					std::cout << " time = " << time ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				++i;
			}
			//判断中型车位侧边(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info_ex(parkingspace_index_id));
				parkspace_info.set_path_estimate_time(time_min);
				parkspace_info.set_parkspace_path(message::LEFT_PATH);
				parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
				return Error_code::SUCCESS;
			}
		}
	}
	if ( car_info.car_height() <= BIG_CAR_HIGH )
	{
		//找大型车位
		//获取大型车位
		message::Parkspace_allocation_data_msg all_big_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_big_parkspace_data,message::Parkspace_type::BIG_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while(i<all_big_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_big_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

			//筛选出一号车库的小型车位的靠近电梯的左侧三排（第二优先级）的空车位
			if ( ( (t_parkspace_id %15 >= 1 && t_parkspace_id %15 <= 3) || (t_parkspace_id>=34 && t_parkspace_id<=42) || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
				 && all_big_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//如果是二楼车 则特殊处理
				if ( all_big_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() == 2 )
				{
					// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float t_min=abs( (t_parkspace_id%15 == 0?15:t_parkspace_id%15)*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_width()-(terminal_id+2)*TERMINAL_SPACING )/MEDIUM_CAR_SPEED+DOWNSTAIRS_SPORTS_TIME;

					if ( time_min == 0 )
					{
						time_min=t_min;
						parkingspace_index_id=i;
					}
					else
					{
						if ( t_min<time_min )
						{
							time_min=t_min;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------left-------"  << std::endl;
					std::cout << " time = " << t_min ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				else
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_big_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
								(t_parkspace_id % 15==0?15:t_parkspace_id % 15)*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if ( time_min == 0 )
					{
						time_min=time;
						parkingspace_index_id=i;

					}
					else
					{
						if ( time<time_min )
						{
							time_min=time;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------left-------"  << std::endl;
					std::cout << " time = " << time ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
			}
			++i;
		}
		//判断大型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::LEFT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则代表左侧没找到合适车位
			parkspace_info.set_parkingspace_index_id(-1);
			return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
								"无合适车位分配！ query_the_optimal_parkspace_serverB1  error ");
		}
	}
	return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
						"无合适车位分配！ query_the_optimal_parkspace_serverB1 error ");

}
//找右侧车位
Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB2(message::Parkspace_info &parkspace_info,message::Car_info car_info,int terminal_id)
{
	//车辆高大于1550mm分在四楼以下，小于1550mm分在四楼以上
	/*
	 * K=j%15
	 * P=i%6
	 * S=15*d-(j%15)*(2*d-1)+[6*d-(i%6)(2*d-1)]*W    W>1
	 */
	float time_min=0;
	int parkingspace_index_id=-1;
	//找右侧车位
	//如果是小车 （低于1.55米属于小车）
	if ( car_info.car_height() <= MIN_CAR_HIGH )
	{
		//获取所有小型车位信息
		message::Parkspace_allocation_data_msg all_min_parkspace_data;
		Error_manager t_error = m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_min_parkspace_data, message::Parkspace_type::MIN_PARKINGSPACE);
		if (t_error != SUCCESS)
		{
			return t_error;
		}
		//遍历所有小型车位
		int i = 0;
		while (i < all_min_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_min_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();
			//筛选出小型车位的中间部分（第一优先级）的空车位
			if (t_parkspace_id % 15 >= 4 && t_parkspace_id % 15 <= 12
				&& all_min_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
			{
				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time = (6-terminal_id+2) * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
							 (all_min_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
							 ( 15-t_parkspace_id % 15 ) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_width() / MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
				if (time_min == 0)
				{
					time_min = time;
					parkingspace_index_id = i;
				}
				else
				{
					if ( time<time_min )
					{
						time_min=time;
						parkingspace_index_id=i;
					}
				}
				std::cout << " ------right-------"  << std::endl;
				std::cout << " time = " << time ;
				std::cout << "              time_min = " << time_min;
				std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
			}
			++i;
		}
		//判断小车车位中间部分(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::RIGHT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找小车车位第二优先级 （侧边）
			int i = 0;
			while (i < all_min_parkspace_data.parkspace_info_ex_size())
			{
				int t_parkspace_id=all_min_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

				//筛选出一号车库的小型车位的中间部分（第一优先级）的空车位
				if ((t_parkspace_id % 15 >= 1 && t_parkspace_id % 15 <= 3 || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
					&& all_min_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time = (6-terminal_id+2) * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
								 (all_min_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 ( (15-t_parkspace_id % 15)==15?0:(15-t_parkspace_id % 15) ) *all_min_parkspace_data.parkspace_info_ex(i).parkingspace_width() / MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if (time_min == 0)
					{
						time_min = time;
						parkingspace_index_id = i;
					}
					else
					{
						if ( time < time_min )
						{
							time_min = time;
							parkingspace_index_id = i;
						}
					}
					std::cout << " ------right-------"  << std::endl;
					std::cout << " time = " << time ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				++i;
			}
			//判断小车车位侧边部分(第二优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info_ex(parkingspace_index_id));
				parkspace_info.set_path_estimate_time(time_min);
				parkspace_info.set_parkspace_path(message::RIGHT_PATH);
				parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
				return Error_code::SUCCESS;
			}
		}
	}
	if ( car_info.car_height() <= MID_CAR_HIGH )
	{
		//找中型车位
		//获取中型车位
		message::Parkspace_allocation_data_msg all_mid_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_mid_parkspace_data,message::Parkspace_type::MID_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while(i<all_mid_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

			//如果是六楼的中型车位的中间部分（第一优先级）
			if ( t_parkspace_id >= 64 && t_parkspace_id <= 72
				 && all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
						   (all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
						   ( 15-t_parkspace_id % 15 )*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
				if ( time_min == 0 )
				{
					time_min=time;
					parkingspace_index_id=i;

				}
				else
				{
					if ( time<time_min )
					{
						time_min=time;
						parkingspace_index_id=i;
					}
				}
				std::cout << " ------right-------"  << std::endl;
				std::cout << " time = " << time;
				std::cout << "              time_min = " << time_min;
				std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
			}
			++i;
		}
		//判断中型车位的中间部分(第一优先级)是否有找到合适的空车位   如果找到了 直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::RIGHT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找侧边中型车位（第二优先级）
			int i=0;
			while(i<all_mid_parkspace_data.parkspace_info_ex_size())
			{
				int t_parkspace_id=all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

				//如果是六楼的中型车位的侧边（第二优先级）
				if ( (t_parkspace_id >=61 && t_parkspace_id <= 63 || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
					 && all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   ( (15-t_parkspace_id % 15) ==15?0:(15-t_parkspace_id % 15))*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if ( time_min == 0 )
					{
						time_min=time;
						parkingspace_index_id=i;

					}
					else
					{
						if ( time<time_min )
						{
							time_min=time;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------right-------"  << std::endl;
					std::cout << " time = " << time;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				++i;
			}
			//判断中型车位侧边(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info_ex(parkingspace_index_id));
				parkspace_info.set_path_estimate_time(time_min);
				parkspace_info.set_parkspace_path(message::RIGHT_PATH);
				parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
				return Error_code::SUCCESS;
			}
		}
	}
	if ( car_info.car_height() <= BIG_CAR_HIGH )
	{
		//找大型车位
		//获取大型车位
		message::Parkspace_allocation_data_msg all_big_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_big_parkspace_data,message::Parkspace_type::BIG_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while(i<all_big_parkspace_data.parkspace_info_ex_size())
		{
			int t_parkspace_id=all_big_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();

			//筛选出大型车位的靠近电梯的右侧三排（第二优先级）的空车位
			if ( ( (t_parkspace_id %15 >= 1 && t_parkspace_id %15 <= 3) || (t_parkspace_id>=34 && t_parkspace_id<=42) || t_parkspace_id % 15 == 13 || t_parkspace_id % 15 ==14 || t_parkspace_id % 15 ==0 )
				 && all_big_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//如果是二楼车 则特殊处理
				if ( all_big_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id() == 2 )
				{
					// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float t_min=abs( (t_parkspace_id%15==0?15:t_parkspace_id%15)*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_width()-(terminal_id+2)*TERMINAL_SPACING )/MEDIUM_CAR_SPEED+DOWNSTAIRS_SPORTS_TIME;
					if ( time_min == 0 )
					{
						time_min=t_min;
						parkingspace_index_id=i;
					}
					else
					{
						if ( t_min<time_min )
						{
							time_min=t_min;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------right-------"  << std::endl;
					std::cout << " time = " << t_min;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
				else
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_big_parkspace_data.parkspace_info_ex(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   ( (15-t_parkspace_id % 15)==15?0:(15-t_parkspace_id % 15) )*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_width()/MEDIUM_CAR_SPEED + UPSTAIRS_SPORTS_TIME;
					if ( time_min == 0 )
					{
						time_min=time;
						parkingspace_index_id=i;

					}
					else
					{
						if ( time<time_min )
						{
							time_min=time;
							parkingspace_index_id=i;
						}
					}
					std::cout << " ------right-------"  << std::endl;
					std::cout << " time = " << time ;
					std::cout << "              time_min = " << time_min;
					std::cout << "  t_parkspace_id = " << t_parkspace_id << std::endl<< std::endl<< std::endl;
				}
			}
			++i;
		}
		//判断大型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::RIGHT_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则代表右侧没找到合适车位
			parkspace_info.set_parkingspace_index_id(-1);
			return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
								 "无合适车位分配!  query_the_optimal_parkspace_serverB2  error ");
		}
	}
	return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
						 " 无合适车位分配! query_the_optimal_parkspace_serverB2 error ");
}
//找缓存区车位
Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB3(message::Parkspace_info &parkspace_info,message::Car_info car_info,int terminal_id)
{
	//车辆高大于1550mm分在四楼以下，小于1550mm分在四楼以上
	/*
	 * K=j%15
	 * P=i%6
	 * S=15*d-(j%15)*(2*d-1)+[6*d-(i%6)(2*d-1)]*W    W>1
	 */
	float time_min=0;
	int parkingspace_index_id=-1;
	//找缓存区车位 缓冲区只有中型车位和大型车位
	if ( car_info.car_height() <= MID_CAR_HIGH )
	{
		message::Parkspace_allocation_data_msg all_mid_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_mid_parkspace_data,message::Parkspace_type::MID_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while (i < all_mid_parkspace_data.parkspace_info_ex_size())
		{
			//筛选中型车位缓冲区
			int t_parkspace_id=all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();
			if ( t_parkspace_id >= 19 && t_parkspace_id <= 27
				&& all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::eParkspace_empty)
			{
				//只需计算端口到车位的距离
				// 三楼中型用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
				float t_min=abs( t_parkspace_id%15*all_mid_parkspace_data.parkspace_info_ex(i).parkingspace_width()-(terminal_id+2)*TERMINAL_SPACING )/MEDIUM_CAR_SPEED+DOWNSTAIRS_SPORTS_TIME;
				if ( time_min == 0 )
				{
					time_min=t_min;
					parkingspace_index_id=i;
				}
				else
				{
					if ( t_min<time_min )
					{
						time_min=t_min;
						parkingspace_index_id=i;
					}
				}
			}
			++i;
		}
		//判断缓冲区的中型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::TEMPORARY_CACHE_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
	}
	if(  car_info.car_height() <= BIG_CAR_HIGH )
	{
		message::Parkspace_allocation_data_msg all_big_parkspace_data;
		Error_manager t_error=m_parkspace_operating_function.get_specify_the_type_parkspace_info(all_big_parkspace_data,message::Parkspace_type::BIG_PARKINGSPACE);
		if(t_error != SUCCESS)
		{
			return t_error;
		}
		int i=0;
		while (i < all_big_parkspace_data.parkspace_info_ex_size())
		{
			//筛选中型车位缓冲区
			int t_parkspace_id=all_big_parkspace_data.parkspace_info_ex(i).parkingspace_index_id();
			if ( t_parkspace_id >= 4 && t_parkspace_id <= 12
				 && all_big_parkspace_data.parkspace_info_ex(i).parkingspace_status() == message::eParkspace_empty)
			{
				//只需计算端口到车位的距离
				// 二楼中型用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
				float t_min=abs( t_parkspace_id%15*all_big_parkspace_data.parkspace_info_ex(i).parkingspace_width()-(terminal_id+2)*TERMINAL_SPACING )/MEDIUM_CAR_SPEED+DOWNSTAIRS_SPORTS_TIME;
				if ( time_min == 0 )
				{
					time_min=t_min;
					parkingspace_index_id=i;
				}
				else
				{
					if ( t_min<time_min )
					{
						time_min=t_min;
						parkingspace_index_id=i;
					}
				}
			}
			++i;
		}

		//判断缓冲区的中型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info_ex(parkingspace_index_id));
			parkspace_info.set_path_estimate_time(time_min);
			parkspace_info.set_parkspace_path(message::TEMPORARY_CACHE_PATH);
			parkspace_info.set_parkspace_status_target(message::eParkspace_locked);
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则代表缓冲区没找到合适车位
			parkspace_info.set_parkingspace_index_id(-1);
			return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
								 "无合适车位分配! query_the_optimal_parkspace_serverB3 error ");
		}
	}
	return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::NEGLIGIBLE_ERROR,
						 " 无合适车位分配! query_the_optimal_parkspace_serverB3 error ");
}
//分配车位线程函数
void Parkspace_manager:: execute_for_allocate(message::Car_info car_info, int terminal_id, std::string command_key)
{
	LOG(INFO) << "分配车位     " << "牌号:" << car_info.license() << "     车高：" << car_info.car_height()
			  << "     command_key=" << command_key;
	//根据请求的信息反馈分配的车位,并封装发送
	message::Parkspace_allocation_response_msg response_msg;
	message::Base_info t_response_header;
	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);
	t_response_header.set_receiver(message::Communicator::eMain);

	message::Error_manager t_error;
	//方案B的车位
	message::Parkspace_info t_allocated_space_left;
	message::Parkspace_info t_allocated_space_rigth;
	message::Parkspace_info t_allocated_space_temporary;

	Error_manager error_B1;
	Error_manager error_B2;
	Error_manager error_B3;

	message::Car_type t_cartype;
	if ( car_info.car_height() <= message::Car_type::MIN_CAR )
	{
		t_cartype = message::Car_type::MIN_CAR;
	}
	else if ( car_info.car_height() > message::Car_type::MIN_CAR && car_info.car_height() <= message::Car_type::MID_CAR )
	{
		t_cartype = message::Car_type::MID_CAR;
	}
	else
	{
		t_cartype = message::Car_type::BIG_CAR;
	}
	//分配之前查询车辆是否已经存在
	if (check_car_existence(car_info.license()))
	{
		t_error.set_error_code(PARKSPACE_ALLOCATOR_CAR_ALREADY_EXIST);
		t_error.set_error_level(message::Error_level::MINOR_ERROR);
		t_error.set_error_description(" The vehicle already exists error");
		LOG(ERROR) << car_info.license() << "   车辆已存在";
	}
	else
	{
		m_parkspace_lock.lock();
		//		如果车辆不存在 则找到一个最优车位(方案B)----分配三个车位  左边分配一个 右边分配一个  缓冲区分配一个   最后使用那个由调度决定
		LOG(INFO) << " 方案B---------分配车位中----------  " << this;
		//获取左侧车位
		error_B1 = query_the_optimal_parkspace_serverB1(t_allocated_space_left, car_info, terminal_id);
		if (error_B1 != Error_code::SUCCESS)
		{
			LOG(ERROR) << car_info.license() << " 获取左侧车位失败  " << error_B1.to_string();
		}
		else
		{
			t_allocated_space_left.set_parkingspace_status(message::Parkspace_status::eParkspace_locked);
			t_allocated_space_left.mutable_car_info()->CopyFrom(car_info);
			t_allocated_space_left.set_car_type(t_cartype);
			// 分配车位后更新数据库中车位状态--左车位
			error_B1 = m_parkspace_operating_function.update_parkspace_data(t_allocated_space_left);
			if (error_B1 != SUCCESS)
			{
				LOG(ERROR) << car_info.license() << " 左车位更新数据失败  " << error_B1.to_string();
			}
			else
			{
				response_msg.add_allocated_parkspace_info_ex()->CopyFrom(t_allocated_space_left);
				LOG(INFO) << " ----- 左  车  位ID:  " << t_allocated_space_left.parkingspace_index_id() << "-----";
			}
		}
		//获取右侧车位
		error_B2 = query_the_optimal_parkspace_serverB2(t_allocated_space_rigth, car_info, terminal_id);
		if (error_B2 != Error_code::SUCCESS)
		{
			LOG(ERROR) << car_info.license() << " 获取右侧车位失败  " << error_B2.to_string();
		}
		else
		{
			t_allocated_space_rigth.set_parkingspace_status(message::Parkspace_status::eParkspace_locked);
			t_allocated_space_rigth.mutable_car_info()->CopyFrom(car_info);
			t_allocated_space_rigth.set_car_type(t_cartype);

			// 分配车位后更新数据库中车位状态--右车位
			error_B2 = m_parkspace_operating_function.update_parkspace_data(t_allocated_space_rigth);
			if (error_B2 != SUCCESS)
			{
				LOG(ERROR) << car_info.license() << " 右车位更新数据失败  " << error_B2.to_string();
			}
			else
			{
				response_msg.add_allocated_parkspace_info_ex()->CopyFrom(t_allocated_space_rigth);
				LOG(INFO) << " ----- 右  车  位ID:  " << t_allocated_space_rigth.parkingspace_index_id() << "-----";
			}
		}
		//获取缓冲区车位
		error_B3 = query_the_optimal_parkspace_serverB3(t_allocated_space_temporary, car_info, terminal_id);
		if (error_B3 != Error_code::SUCCESS)
		{
			LOG(ERROR) << car_info.license() << " 获取缓冲区车位失败  " << error_B3.to_string();
		}
		else
		{
			t_allocated_space_temporary.set_parkingspace_status(message::Parkspace_status::eParkspace_locked);
			t_allocated_space_temporary.mutable_car_info()->CopyFrom(car_info);
			t_allocated_space_temporary.set_car_type(t_cartype);
			// 分配车位后更新数据库中车位状态--缓冲车位
			error_B3 = m_parkspace_operating_function.update_parkspace_data(t_allocated_space_temporary);
			if (error_B3 != SUCCESS)
			{
				LOG(ERROR) << car_info.license() << " 缓冲车位更新数据失败  " << error_B3.to_string();
			}
			else
			{
				response_msg.add_allocated_parkspace_info_ex()->CopyFrom(t_allocated_space_temporary);
				LOG(INFO) << " -----缓冲车位车位ID:  " << t_allocated_space_temporary.parkingspace_index_id() << "-----";
			}
		}
		Error_manager error_total;
		error_total.compare_and_cover_error(error_B1);
		error_total.compare_and_cover_error(error_B2);
		error_total.compare_and_cover_error(error_B3);
		if ( error_B1==SUCCESS || error_B2==SUCCESS || error_B3==SUCCESS )
		{
			t_error.set_error_code(SUCCESS);
			t_error.set_error_level(message::Error_level::NORMAL);
			LOG(INFO) << "  	分配车位成功! ";
		}
		else
		{
			t_error.set_error_code(PARKSPACE_ALLOCATOR_ALLOCATE_FAILED);
			t_error.set_error_level(message::Error_level::MINOR_ERROR);
			t_error.set_error_description(error_total.get_error_description());
			LOG(INFO) << "  				分配车位失败，无车位! ";
		}

	}
	m_parkspace_lock.unlock();
	response_msg.mutable_base_info()->CopyFrom(t_response_header);
	response_msg.set_command_key(command_key);
	response_msg.mutable_error_manager()->CopyFrom(t_error);
	response_msg.set_car_type(t_cartype);


	Communication_message response = Communication_message();
	response.reset(t_response_header, response_msg.SerializeAsString());
	Parkspace_communicator::get_instance_references().send_response(&response);
	send_parkspace_data();
	std::cout << std::endl;
}
//确认分配车位线程函数
void Parkspace_manager::execute_for_confirm_alloc(message::Parkspace_confirm_alloc_request_msg request)
{
	LOG(INFO) << "确认分配    "<< this;
	message::Parkspace_confirm_alloc_response_msg response_msg;
	message::Base_info t_response_header;
	t_response_header.set_msg_type(message::eParkspace_confirm_alloc_response_msg);
	t_response_header.set_sender(message::eParkspace);
	t_response_header.set_receiver(message::eMain);
	t_response_header.set_timeout_ms(1000);
	message::Error_manager t_error;
	t_error.set_error_code(Error_code::SUCCESS);
	t_error.set_error_level(message::Error_level::NORMAL);

	//确认的车位
	message::Parkspace_info confirm_alloc_space_info;

	//释放的车位
	message::Parkspace_info release_alloc_space_info;


	for (int i = 0; i < request.confirm_parkspace_info_ex().size(); ++i)
	{
		//核对确认车位信息
		m_parkspace_operating_function.query_one_parkspace_with_parkspace_id(request.confirm_parkspace_info_ex(i).parkingspace_index_id(),confirm_alloc_space_info);

		if ( request.confirm_parkspace_info_ex(i).parkspace_status_target() == message::eParkspace_occupied && \
			 confirm_alloc_space_info.parkingspace_status() == message::Parkspace_status::eParkspace_locked	)
		{

			LOG(INFO) << "方案B---------确认分配     车位id:" <<request.confirm_parkspace_info_ex(i).parkingspace_index_id()<< "		车牌号:" << request.confirm_parkspace_info_ex(i).car_info().license() ;
			Error_manager error=confirm_alloc_function(request.confirm_parkspace_info_ex(i),confirm_alloc_space_info);
			if ( error != SUCCESS )
			{
				t_error.set_error_code(error.get_error_code());
				t_error.set_error_level((message::Error_level)error.get_error_level());
				t_error.set_error_description(error.get_error_description());
			}
			else
			{
				response_msg.add_confirm_parkspace_info_ex()->CopyFrom(confirm_alloc_space_info);
			}


		}
		else if ( request.confirm_parkspace_info_ex(i).parkspace_status_target() == message::eParkspace_empty && \
				 confirm_alloc_space_info.parkingspace_status() == message::Parkspace_status::eParkspace_locked	)
		{
			Error_manager error=release_parkspace_function(request.confirm_parkspace_info_ex(i),release_alloc_space_info,false);
			if ( error != SUCCESS )
			{
				t_error.set_error_code(error.get_error_code());
				t_error.set_error_level((message::Error_level)error.get_error_level());
				t_error.set_error_description(error.get_error_description());
			}
		}
		else
		{
			t_error.set_error_code(PARKSPACE_ALLOCATOR_PARAM_ERROR);
			t_error.set_error_level(message::Error_level::MINOR_ERROR);
			t_error.set_error_description("Parking information does not match or the target status of the parking space is wrong error!");
			LOG(INFO) << "确认分配失败 车位信息不匹配或目标车位状态错误错误!  id:"<<request.confirm_parkspace_info_ex(i).parkingspace_index_id()<<"    数据库车位状态:"<<confirm_alloc_space_info.parkingspace_status()<<"   号牌:"<<request.confirm_parkspace_info_ex(i).car_info().license()<<"		"<< this;

		}
	}


	response_msg.mutable_base_info()->CopyFrom(t_response_header);
	response_msg.set_command_key(request.command_key());
	response_msg.mutable_error_manager()->CopyFrom(t_error);
	response_msg.set_car_type(request.car_type());

	Communication_message response=Communication_message();
	response.reset(t_response_header, response_msg.SerializeAsString());
	Parkspace_communicator::get_instance_references().send_response(&response);

	send_parkspace_data();
	std::cout<<std::endl;
}
//查询车位线程函数
void Parkspace_manager::execute_for_search(message::Car_info car_info,std::string command_key)
{
	LOG(INFO) << "查询车位     "<<"牌号:"<<car_info.license()<<"     command_key="<<command_key;
	//根据车辆凭证信息查询车辆位置
	message::Parkspace_search_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_search_response_msg);
	t_response_header.set_timeout_ms(1000);
	t_response_header.set_sender(message::Communicator::eParkspace);
	t_response_header.set_receiver(message::Communicator::eMain);
	//查询车辆位置
	message::Parkspace_info parkspace_info;
	Error_manager error=m_parkspace_operating_function.query_one_parkspace_with_license(car_info.license(),parkspace_info);
	if ( error != SUCCESS )
	{
		t_error.set_error_code(error.get_error_code());
		t_error.set_error_level((message::Error_level)error.get_error_level());
		t_error.set_error_description(error.get_error_description());
		LOG(ERROR) << "查询车位失败     "<<error.to_string();
	}
	else
	{
		t_error.set_error_code(SUCCESS);
		t_error.set_error_level(message::Error_level::NORMAL);
		LOG(INFO) << "车辆"<<parkspace_info.car_info().license()<<"     在"<<parkspace_info.parkingspace_index_id()<<"号车位上";
	}
	response_msg.mutable_base_info()->CopyFrom(t_response_header);
	response_msg.set_command_key(command_key);
	response_msg.mutable_error_manager()->CopyFrom(t_error);
	response_msg.mutable_query_parkspace_info_ex()->Add()->CopyFrom(parkspace_info);
	Communication_message response=Communication_message();
	response.reset(t_response_header, response_msg.SerializeAsString());
	Parkspace_communicator::get_instance_references().send_response(&response);
	std::cout<<std::endl;
}

//释放车位线程函数
void Parkspace_manager::execute_for_release(message::Parkspace_release_request_msg release_msg, std::string command_key)
{

	LOG(INFO) << "释放车位     ";
	//根据车位信息定位待释放车位位置，车辆凭证号用于校验
	message::Parkspace_release_response_msg response_msg;
	message::Base_info t_response_header;
	t_response_header.set_msg_type(message::eParkspace_release_response_msg);
	t_response_header.set_sender(message::eParkspace);
	t_response_header.set_receiver(message::eMain);
	t_response_header.set_timeout_ms(1000);
	message::Error_manager t_error;
	t_error.set_error_code(Error_code::SUCCESS);
	t_error.set_error_level(message::Error_level::NORMAL);
	message::Parkspace_info t_release_space;
	for (int i = 0; i < release_msg.release_parkspace_info_ex_size(); ++i)
	{
		//将传入数据与数据库数据进行核对
		m_parkspace_operating_function.query_one_parkspace_with_parkspace_id(release_msg.release_parkspace_info_ex(i).parkingspace_index_id(),t_release_space);

		if ( !release_msg.release_parkspace_info_ex(i).has_car_info() || \
			t_release_space.car_info().license() != release_msg.release_parkspace_info_ex(i).car_info().license() )
		{
			t_error.set_error_code(PARKSPACE_ALLOCATOR_PARAM_ERROR);
			t_error.set_error_level(message::Error_level::MINOR_ERROR);
			t_error.set_error_description(" Incoming parking space data to be released does not match the database data error");
			LOG(INFO) << "释放车位失败  传入待释放车位数据与数据库数据不匹配  "<< this;
		}
		else
		{
			Error_manager error=release_parkspace_function(release_msg.release_parkspace_info_ex(i),t_release_space,true);
			if ( error != SUCCESS )
			{
				t_error.set_error_code(error.get_error_code());
				t_error.set_error_level((message::Error_level)error.get_error_level());
				t_error.set_error_description(error.get_error_description());

			}
		}
	}


	response_msg.mutable_base_info()->CopyFrom(t_response_header);
	response_msg.set_command_key(command_key);
	response_msg.mutable_error_manager()->CopyFrom(t_error);
	response_msg.mutable_release_parkspace_info_ex()->Add()->CopyFrom(t_release_space);

	Communication_message response=Communication_message();
	response.reset(t_response_header, response_msg.SerializeAsString());
	Parkspace_communicator::get_instance_references().send_response(&response);

	send_parkspace_data();
	std::cout<<std::endl;
}

//强制更新车位信息线程函数
void Parkspace_manager::execute_for_force_update(message::Parkspace_force_update_request_msg space_info, std::string command_key)
{

	LOG(INFO) << "手动   "<<"牌号:"<<space_info.manual_parkspace_info_ex(0).car_info().license()<<"   command_key="<<command_key;
	//根据车位信息定位待释放车位位置，车辆凭证号用于校验
	//!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
	message::Parkspace_force_update_response_msg response_msg;
	message::Base_info t_response_header;
	t_response_header.set_msg_type(message::eParkspace_force_update_response_msg);
	t_response_header.set_sender(message::eParkspace);
	t_response_header.set_receiver(message::eMain);
	t_response_header.set_timeout_ms(1000);
	message::Error_manager t_error;
	message::Parkspace_info t_update_space;
	Error_manager error;
	// id 9999为特殊情况，复位所有车位状态
	if (space_info.manual_parkspace_info_ex(0).parkingspace_index_id() == 9999)
	{
		// 复位所有车位状态
		error=m_parkspace_operating_function.clear_all_parkspace_info();
		if( error != SUCCESS)
		{
			t_error.set_error_code(error.get_error_code());
			t_error.set_error_level((message::Error_level) error.get_error_level());
			LOG(INFO) << "手动更新所有车位失败 "<<error.to_string();
		}
		else
		{
			t_error.set_error_code(SUCCESS);
			t_error.set_error_level(message::Error_level::NORMAL);
			LOG(INFO) << "所有车位已手动更新 ";
		}
	}
	else
	{
		//手动修改车位信息
		error  = m_parkspace_operating_function.update_parkspace_data(t_update_space);
		if (error != SUCCESS)
		{
			t_error.set_error_code(error.get_error_code());
			t_error.set_error_level((message::Error_level)error.get_error_level());
			LOG(INFO) << "手动  数据库更新车位失败  "<<error.to_string();
		}
		else
		{
			t_error.set_error_code(SUCCESS);
			t_error.set_error_level(message::Error_level::NORMAL);
			LOG(INFO) << "第" << t_update_space.parkingspace_index_id() << "号位已手动更新";
		}
	}

	response_msg.mutable_base_info()->CopyFrom(t_response_header);
	response_msg.set_command_key(command_key);
	response_msg.mutable_error_manager()->CopyFrom(t_error);
	response_msg.mutable_manual_parkspace_info_ex()->Add()->CopyFrom(t_update_space);
	Communication_message response=Communication_message();
	response.reset(t_response_header, response_msg.SerializeAsString());
	Parkspace_communicator::get_instance_references().send_response(&response);

	send_parkspace_data();
}
//确认分配操作函数、
Error_manager Parkspace_manager::confirm_alloc_function(message::Parkspace_info space_info,message::Parkspace_info& t_confirm_space)
{
	//根据车位信息定位待确认占用车位
	Error_manager error;
	//记录当前传入车辆的状态  为后续回退操作服务
	message::Parkspace_status t_parkingspace_status=space_info.parkingspace_status();
	if (!space_info.has_car_info())
	{
		LOG(WARNING) << "传入待确认车位无车辆信息";
		return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
							 " 确认分配车位传入参数无车辆信息! ");
	}
	t_confirm_space.CopyFrom(space_info);
	if(t_confirm_space.parkspace_status_target() == message::eParkspace_occupied && space_info.has_car_info())
	{
		//更新车位数据1
		t_confirm_space.set_parkingspace_status(message::eParkspace_occupied);
		error = m_parkspace_operating_function.update_parkspace_data(t_confirm_space);
		if (error != SUCCESS)
		{
			LOG(INFO) << "确认分配  数据库更新车位数据失败  " << error.to_string();
			return error;
		}
		else
		{
			//修改车辆状态为已入库
			message::Vehicle_status t_vehicle_status = message::Vehicle_status::eVehicle_in_garage;
			error = m_parkspace_operating_function.update_vehicle_with_parkspace(t_confirm_space, t_vehicle_status);
			if (error != SUCCESS)
			{
				//此处操作不成功就需要回退  因为前一步骤更改了车位表信息导致二表不统一
				LOG(ERROR) << "确认分配 更新数据库车辆数据失败  进行回退---" << error.to_string();
				t_confirm_space.set_parkingspace_status(t_parkingspace_status);
				t_confirm_space.set_parkspace_status_target(t_parkingspace_status);
				for (int i = 1; i < 4; ++i)
				{
					Error_manager e = m_parkspace_operating_function.update_parkspace_data(t_confirm_space);
					if (e != SUCCESS)
					{
						LOG(INFO) << "回退第"<<i<<"次 失败！  " << e.to_string();
						continue;
					}
					else
					{
					    LOG(INFO) << " 回退成功! ";
						return e;
					}
				}
				//如果流程进行到这里说明回退三次都失败 需要报三级故障
				return Error_manager(Error_code::DB_UPDATE_FAILED, Error_level::MAJOR_ERROR,
									" update database error ");
			}
			error.set_error_code(SUCCESS);
			error.set_error_level_location(Error_level::NEGLIGIBLE_ERROR);
			LOG(INFO) << "第：" << t_confirm_space.parkingspace_index_id() << "号位     车辆: " << t_confirm_space.car_info().license()<< "     确认占用成功";
			//插入停车记录
			time_t tt = time(NULL);
			tm *t = localtime(&tt);
			char my_time_buf[255];
			memset(my_time_buf, 0, 255);
			sprintf(my_time_buf, "%d-%02d-%02d %02d:%02d:%02d",
					t->tm_year + 1900,
					t->tm_mon + 1,
					t->tm_mday,
					t->tm_hour,
					t->tm_min,
					t->tm_sec);
			t_confirm_space.set_entry_time(my_time_buf);
			error = m_parkspace_operating_function.insert_parking_record(t_confirm_space);
			if ( error != SUCCESS )
			{
				LOG(ERROR) << "插入停车记录失败: " << error.to_string();
			}
			//查询停车记录的ID
			int t_record_id;
			error = m_parkspace_operating_function.query_parking_record(t_confirm_space,t_record_id);
			if ( error != SUCCESS )
			{
				LOG(ERROR) << "查询停车记录ID失败: " << error.to_string();
			}
			//更新停车记录ID
			error = m_parkspace_operating_function.update_record_id(t_confirm_space.car_info().license(),t_record_id);
			if ( error != SUCCESS )
			{
				LOG(ERROR) << "更新停车记录ID失败: " << error.to_string();
			}
		}
	}
	return error;
}
//释放车位操作函数
Error_manager Parkspace_manager::release_parkspace_function(message::Parkspace_info target_space_info,message::Parkspace_info& release_parkspace_info,bool flag)
{
	Error_manager error;

	if(!target_space_info.has_car_info())
	{
		LOG(WARNING) << "传入待释放车位无车辆信息";
		return error;
	}
	release_parkspace_info.CopyFrom(target_space_info);

	if(release_parkspace_info.parkspace_status_target() == message::eParkspace_empty && release_parkspace_info.has_car_info())
	{
		release_parkspace_info.set_parkingspace_status(message::eParkspace_empty);
		error = m_parkspace_operating_function.update_parkspace_data(release_parkspace_info);
		if (error != SUCCESS)
		{
			LOG(ERROR) << "释放车位 更新数据库车位数据失败   " << error.to_string();
			return error;
		}
		else
		{
			if ( flag == false )
			{
				error.set_error_code(SUCCESS);
				error.set_error_level_location(Error_level::NORMAL);
				LOG(INFO) << "不更新车辆表释放 --- 第：" << release_parkspace_info.parkingspace_index_id() << "号位     车辆: " << release_parkspace_info.car_info().license()
						  << "     释放成功";
			}
			else
			{

				message::Vehicle_status t_vehicle_status;
				//获取预约ID
				int t_park_record_id;
				error = m_parkspace_operating_function.query_vehicle(release_parkspace_info.car_info().license(),
																	 t_vehicle_status, t_park_record_id);
				if (error != SUCCESS)
				{
					LOG(ERROR) << "释放车位 数据库查询车辆信息失败 " << error.to_string();
				}
				t_vehicle_status=message::eVehicle_idle;
				error = m_parkspace_operating_function.update_vehicle_with_parkspace(release_parkspace_info, t_vehicle_status);
				if (error != SUCCESS)
				{
					LOG(ERROR) << "释放车位 更新数据库车辆数据失败 " << error.to_string();
					return error;
				}
				error.set_error_code(SUCCESS);
				error.set_error_level_location(Error_level::NORMAL);
				LOG(INFO) << "更新车辆表--- 第：" << release_parkspace_info.parkingspace_index_id() << "号位     车辆: " << release_parkspace_info.car_info().license()
						  << "     释放成功";

				time_t tt = time(NULL);
				tm *t = localtime(&tt);
				char my_time_buf[255];
				memset(my_time_buf, 0, 255);
				sprintf(my_time_buf, "%d-%02d-%02d %02d:%02d:%02d",
						t->tm_year + 1900,
						t->tm_mon + 1,
						t->tm_mday,
						t->tm_hour,
						t->tm_min,
						t->tm_sec);
				release_parkspace_info.set_leave_time(my_time_buf);
				error = m_parkspace_operating_function.update_parking_record(release_parkspace_info, t_park_record_id);
				if (error != SUCCESS)
				{
					LOG(ERROR) << "更新停车记录失败: " << error.to_string();
				}

			}
		}
	}
	return error;
}