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, parkspace id: "<<request.release_space_info().parkingspace_index_id();
            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.release_space_info(), 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 id: "<<request.update_space_info().parkingspace_index_id();
            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.update_space_info(), 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, parkspace id: "<<request.confirm_space_info().parkingspace_index_id();
            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.confirm_space_info(), request.command_key());
            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);

	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_serverA(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 ( terminal_id<=3 && terminal_id>=0 )
	{
		LOG(INFO) << " 左半库 车牌号："<<car_info.license()<<"  车高："<<car_info.car_height()<< this;
		//如果是小车 （低于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_size())
			{
				int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();
				//筛选出一号车库的小型车位（第一优先级）的空车位
				if (room_id %15 <= 8 && room_id %15 >= 1
					&& all_min_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time = terminal_id * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
								 (all_min_parkspace_data.parkspace_info(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 (all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断小车车位(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
				return Error_code::SUCCESS;
			}
			else
			{
				LOG(INFO) << " 小车车位未找到合适车位 "<< this;
			}
		}
		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_size())
			{
				//三楼的中型车位有单独的中跑车停车  且机械臂可以直接抓车到三楼
				int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

				if ( room_id >= 19 && room_id <= 23)
				{
				    //只需计算端口到车位的距离
					// 三楼中型用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float t_min=abs( room_id%15*all_mid_parkspace_data.parkspace_info(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;
						}
					}
				}
				//如果是六楼的中型车位
				if ( room_id <= 68 && room_id >=61
					&& all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
								all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_mid_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断中型车位(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
				return Error_code::SUCCESS;
			}
			else
			{
				LOG(INFO) << " 中车车位未找到合适车位 "<< this;
			}
		}
		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_size())
			{
				int room_id=all_big_parkspace_data.parkspace_info(i).parkingspace_index_id();
				//筛选出一号车库的大型车位
				if ( room_id%15 <= 8 && room_id %15 >=1
					 && all_big_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
				{
					//如果是二楼车 则特殊处理
					if ( all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id() == 2 )
					{
						// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
						float t_min=abs( room_id%15*all_big_parkspace_data.parkspace_info(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;
							}
						}
					}
					else
					{
						//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
						float time=(terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
								   (all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
								   all_big_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_big_parkspace_data.parkspace_info(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;
							}
						}
					}
				}
				++i;
			}
			//判断大型车位(第三优先级)是否有找到合适的空车位   如果找到了  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
				return Error_code::SUCCESS;
			}
			else
			{
			    return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::MINOR_ERROR,
			    					" query_the_optimal_parkspace_serverA error ");
			}
		}
	}
	//判断是否是右半库
	else if(terminal_id<=6 && terminal_id>=4)
	{
		//如果是小车 （低于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_size())
			{
				int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//筛选出一号车库的小型车位（第一优先级）的空车位
				if (room_id  <= 165 && room_id  >= 54
					&& all_min_parkspace_data.parkspace_info(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(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 (15-all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断小车车位(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
			{
				int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//三楼的中型车位有单独的中跑车停车  且机械臂可以直接抓车到三楼
				if ( room_id >= 24 && room_id <= 27 )
				{
					//只需计算端口到车位的距离
					// 三楼中型车位用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float parkingspace_width=15-room_id%15;
					if ( room_id%15==0 )
					{
						parkingspace_width=0;
					}
					float t_min=abs( parkingspace_width*all_mid_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
						}
					}
				}
				if ( room_id <= 75 && room_id >= 69
					 && all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   (15-all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15)*all_mid_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断中型车位(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
			{
				int room_id=all_big_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//筛选出二号车库的大型车位的空车位
				if ( room_id %15 >=9 && room_id %15 <=14 || room_id %15 == 0
					&& all_big_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
				{
					//如果是二楼车 则特殊处理
					if ( all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id() == 2 )
					{
						// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
						float parkingspace_width=15-room_id%15;
						if ( room_id%15==0 )
						{
							parkingspace_width=0;
						}
						float t_min=abs( parkingspace_width*all_big_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
							}
						}
					}
					else
					{
						//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
						float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
								   (all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
									(15-all_big_parkspace_data.parkspace_info(i).parkingspace_index_id()%15)*all_big_parkspace_data.parkspace_info(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;
							}
						}
					}
				}
				++i;
			}
			//判断大型车位(第三优先级)是否有找到合适的空车位   如果找到了  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
				return Error_code::SUCCESS;
			}
			else
			{
				return Error_manager(Error_code::PARKSPACE_ALLOCATOR_ALLOCATE_FAILED, Error_level::MINOR_ERROR,
									 " query_the_optimal_parkspace_serverA error ");
			}
		}
	}
	else
	{
	    return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
	    					"query_the_optimal_parkspace_serverA error ");
	}
}
//找到一个最优车位---方案二
//找左侧车位
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_size())
		{
			int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();
			//筛选出小型车位的中间部分（第一优先级）的空车位
			if (room_id % 15 <= 8 && room_id % 15 >= 4
				&& all_min_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
			{
				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time = terminal_id * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
							 (all_min_parkspace_data.parkspace_info(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
							 (15-all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
					}
				}
			}
			++i;
		}
		//判断小车车位中间部分(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找小车车位第二优先级 （侧边）
			int i = 0;
			while (i < all_min_parkspace_data.parkspace_info_size())
			{
				int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//筛选出一号车库的小型车位的中间部分（第一优先级）的空车位
				if (room_id % 15 <= 3 && room_id % 15 >= 1
					&& all_min_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time = terminal_id * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
								 (all_min_parkspace_data.parkspace_info(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 (15-all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断小车车位侧边部分(第二优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
		{
			int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

			//如果是六楼的中型车位的中间部分（第一优先级）
			if ( room_id >=64 && room_id <= 68
				 && all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							(15-all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15)*all_mid_parkspace_data.parkspace_info(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;
					}
				}
			}
			++i;
		}
		//判断中型车位的中间部分(第一优先级)是否有找到合适的空车位   如果找到了 直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
			return Error_code::SUCCESS;
		}
		else
		{
		    //如果没找到则找侧边中型车位（第二优先级）
			int i=0;
			while(i<all_mid_parkspace_data.parkspace_info_size())
			{
				int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//如果是六楼的中型车位的侧边（第二优先级）
				if ( room_id >=61 && room_id <= 63
					 && all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_mid_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断中型车位侧边(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
		{
			int room_id=all_big_parkspace_data.parkspace_info(i).parkingspace_index_id();

			//筛选出一号车库的小型车位的靠近电梯的左侧三排（第二优先级）的空车位
			if ( room_id %15 == 1 || room_id %15 == 2 || room_id %15 == 3 || room_id>=34 && room_id<=38
				 && all_big_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//如果是二楼车 则特殊处理
				if ( all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id() == 2 )
				{
					// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float t_min=abs( room_id%15*all_big_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
						}
					}
				}
				else
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   all_big_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_big_parkspace_data.parkspace_info(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;
						}
					}
				}
			}
			++i;
		}
		//判断大型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
			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::PARAMETER_ERROR, Error_level::MINOR_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_size())
		{
			int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();
			//筛选出小型车位的中间部分（第一优先级）的空车位
			if (room_id % 15 >= 9 && room_id % 15 <= 12
				&& all_min_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
			{
				//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
				float time = terminal_id * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
							 (all_min_parkspace_data.parkspace_info(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
							 (15-all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
					}
				}
			}
			++i;
		}
		//判断小车车位中间部分(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找小车车位第二优先级 （侧边）
			int i = 0;
			while (i < all_min_parkspace_data.parkspace_info_size())
			{
				int room_id=all_min_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//筛选出一号车库的小型车位的中间部分（第一优先级）的空车位
				if (room_id % 15 == 13 || room_id % 15 == 14 || room_id % 15 == 0
					&& all_min_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty)
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time = terminal_id * TERMINAL_SPACING / MEDIUM_CAR_SPEED + DOWNSTAIRS_SPORTS_TIME +
								 (all_min_parkspace_data.parkspace_info(i).parkingspace_floor_id() - 2) *all_min_parkspace_data.parkspace_info(i).parkingspace_height() /THE_ELEVATOR_SPEED +ELEVATOR_MOVEMENT_TIME +
								 (15-all_min_parkspace_data.parkspace_info(i).parkingspace_index_id() % 15) *all_min_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断小车车位侧边部分(第二优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
		{
			int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

			//如果是六楼的中型车位的中间部分（第一优先级）
			if ( room_id >= 69 && room_id <= 72
				 && all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
						   all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_mid_parkspace_data.parkspace_info(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;
					}
				}
			}
			++i;
		}
		//判断中型车位的中间部分(第一优先级)是否有找到合适的空车位   如果找到了 直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
			return Error_code::SUCCESS;
		}
		else
		{
			//如果没找到则找侧边中型车位（第二优先级）
			int i=0;
			while(i<all_mid_parkspace_data.parkspace_info_size())
			{
				int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();

				//如果是六楼的中型车位的侧边（第二优先级）
				if ( room_id >=73 && room_id <= 75
					 && all_mid_parkspace_data.parkspace_info(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(i).parkingspace_floor_id()-2)*all_mid_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_mid_parkspace_data.parkspace_info(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;
						}
					}
				}
				++i;
			}
			//判断中型车位侧边(第二优先级)是否有找到合适的空车位   如果找到了 直接返回
			if ( time_min!=0 && parkingspace_index_id!=-1 )
			{
				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
				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_size())
		{
			int room_id=all_big_parkspace_data.parkspace_info(i).parkingspace_index_id();

			//筛选出大型车位的靠近电梯的右侧三排（第二优先级）的空车位
			if ( room_id %15 == 13 || room_id %15 == 14 || room_id %15 == 0|| room_id>=39 && room_id<=42
				 && all_big_parkspace_data.parkspace_info(i).parkingspace_status() == message::Parkspace_status::eParkspace_empty )
			{
				//如果是二楼车 则特殊处理
				if ( all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id() == 2 )
				{
					// 二楼用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
					float t_min=abs( room_id%15*all_big_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
						}
					}
				}
				else
				{
					//用时=目标终端到电梯口的距离/中跑车速度+(目标车位楼层-2)*楼层高度/电梯速度+电梯口到目标车位的距离/中跑车速度
					float time=(6-terminal_id+2)*TERMINAL_SPACING/MEDIUM_CAR_SPEED  + DOWNSTAIRS_SPORTS_TIME +
							   (all_big_parkspace_data.parkspace_info(i).parkingspace_floor_id()-2)*all_big_parkspace_data.parkspace_info(i).parkingspace_height()/THE_ELEVATOR_SPEED + ELEVATOR_MOVEMENT_TIME +
							   all_big_parkspace_data.parkspace_info(i).parkingspace_index_id()%15*all_big_parkspace_data.parkspace_info(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;
						}
					}
				}
			}
			++i;
		}
		//判断大型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
			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::PARAMETER_ERROR, Error_level::MINOR_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_size())
		{
			//筛选中型车位缓冲区
			int room_id=all_mid_parkspace_data.parkspace_info(i).parkingspace_index_id();
			if ( room_id >= 19 && room_id <= 27
				&& all_mid_parkspace_data.parkspace_info(i).parkingspace_status() == message::eParkspace_empty)
			{
				//只需计算端口到车位的距离
				// 三楼中型用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
				float t_min=abs( room_id%15*all_mid_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
					}
				}
			}
		}
		//判断缓冲区的中型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
			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_size())
		{
			//筛选中型车位缓冲区
			int room_id=all_big_parkspace_data.parkspace_info(i).parkingspace_index_id();
			if ( room_id >= 4 && room_id <= 12
				 && all_big_parkspace_data.parkspace_info(i).parkingspace_status() == message::eParkspace_empty)
			{
				//只需计算端口到车位的距离
				// 二楼中型用时=| 目标车位到电梯的距离 - 终端到电梯的距离 | / 中跑车速度
				float t_min=abs( room_id%15*all_big_parkspace_data.parkspace_info(i).parkingspace_width()-(6-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;
					}
				}
			}
		}
		//判断缓冲区的中型车位是否有找到合适的空车位   如果找到了  直接返回
		if ( time_min!=0 && parkingspace_index_id!=-1 )
		{
			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
			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::PARAMETER_ERROR, Error_level::MINOR_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()<<"     command_key="<<command_key;  //huli printf 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;
	message::Parkspace_info t_allocated_space;

	Error_manager error;
	//分配之前查询车辆是否已经存在
	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::MAJOR_ERROR);
		t_error.set_error_description("车辆已存在");
		LOG(ERROR) << car_info.license()<<"   车辆已存在";
	}
	else
	{
		m_parkspace_lock.lock();
		//如果车辆不存在 则找到一个最优车位
		error=query_the_optimal_parkspace_serverA(t_allocated_space,car_info,terminal_id);
//		query_the_optimal_parkspace_serverA(t_allocated_space,car_info,terminal_id);
		//如果车辆不存在则获取一个空车位
//		error=m_parkspace_operating_function.query_one_empty_parkspace(t_allocated_space);

		if ( error != Error_code::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) << car_info.license()<<" 获取空车位失败  "<<error.to_string();
		}
		else
		{
			//修改车为状态为锁定
			t_allocated_space.set_parkingspace_status(message::Parkspace_status::eParkspace_locked);
			t_allocated_space.mutable_car_info()->CopyFrom(car_info);
			// 分配车位后更新车位状态
			error=m_parkspace_operating_function.update_parkspace_data(t_allocated_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());
				t_error.set_error_description(error.get_error_description());
				LOG(ERROR) << car_info.license()<<" 更新车位数据失败  "<<error.to_string();
			}
			else
			{
				//修改车辆状态为停车中
				message::Vehicle_status t_vehicle_status = message::Vehicle_status::eVehicle_parking;
				error=m_parkspace_operating_function.update_vehicle_with_parkspace(t_allocated_space,t_vehicle_status);
				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) << car_info.license()<<" 更新车辆数据失败  "<<error.to_string();
				}
				else
				{
					t_error.set_error_code(SUCCESS);
					t_error.set_error_level(message::Error_level::NORMAL);
					LOG(INFO) <<"分配车位成功     "<<"车位ID:"<<t_allocated_space.parkingspace_index_id()<<"     车牌号:"<<t_allocated_space.car_info().license();
				}
			}
		}
		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.mutable_allocated_space_info()->CopyFrom(t_allocated_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_search(message::Car_info car_info,std::string command_key)
{
	LOG(INFO) << "查询车位     "<<"牌号:"<<car_info.license()<<"     command_key="<<command_key;  //huli printf command_key
	//根据车辆凭证信息查询车辆位置
	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);
	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_car_position()->CopyFrom(t_car_position);
	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_info space_info, std::string command_key)
{

	LOG(INFO) << "释放车位     "<<"牌号:"<<space_info.car_info().license()<<"     command_key="<<command_key;
	//根据车位信息定位待释放车位位置，车辆凭证号用于校验
	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;
	message::Parkspace_info t_release_space;
	//找到待释放的车位
	m_parkspace_lock.lock();
	Error_manager error=m_parkspace_operating_function.query_one_parkspace_with_parkspace_id(space_info.parkingspace_index_id(),t_release_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());
		t_error.set_error_description(error.get_error_description());
		LOG(ERROR) << "释放车位失败 "<<error.to_string();
	}
	else if(!t_release_space.has_car_info())
	{
		t_error.set_error_code(PARKSPACE_ALLOCATOR_RELEASE_FAILED);
		t_error.set_error_level(message::Error_level::MAJOR_ERROR);
		LOG(WARNING) << "传入待释放车位无车辆信息";
	}
	else
	{
		t_release_space.set_parkingspace_status(message::Parkspace_status::eParkspace_empty);
		error = m_parkspace_operating_function.update_parkspace_data(t_release_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());
			t_error.set_error_description(error.get_error_description());
			LOG(ERROR) << "释放车位 更新数据库车位数据失败   " << error.to_string();
		}
		else
		{
			message::Vehicle_status t_vehicle_status = message::Vehicle_status::eVehicle_idle;
			error = m_parkspace_operating_function.update_vehicle_with_parkspace(t_release_space, t_vehicle_status);
			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) << "第：" << t_release_space.parkingspace_index_id() << "号位     车辆: " << t_release_space.car_info().license()
						  << "     释放成功";

				//获取预约ID
				int t_park_record_id;
				error = m_parkspace_operating_function.query_vehicle(t_release_space.car_info().license(),
																	 t_vehicle_status, t_park_record_id);
				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 if (t_vehicle_status == message::Vehicle_status::eVehicle_idle)
				{
					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_release_space.set_leave_time(my_time_buf);
					error = m_parkspace_operating_function.update_parking_record(t_release_space, t_park_record_id);
					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();
					}
				}
			}
		}
	}
	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.mutable_release_space_info()->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_info space_info, std::string command_key)
{

	LOG(INFO) << "手动   "<<"牌号:"<<space_info.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.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_update_space_info()->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();
}

//确认分配车位线程函数
void Parkspace_manager::execute_for_confirm_alloc(message::Parkspace_info space_info, std::string command_key)
{

	LOG(INFO) << "确认分配     " << "牌号:" << space_info.car_info().license() << "     command_key=" << command_key;
	//根据车位信息定位待确认占用车位
	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;
	message::Parkspace_info t_confirm_space;
	Error_manager error;
	//获取确认分配的车位
	m_parkspace_lock.lock();
	error = m_parkspace_operating_function.query_one_parkspace_with_parkspace_id(space_info.parkingspace_index_id(),
																				 t_confirm_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());
		t_error.set_error_description(error.get_error_description());
		LOG(ERROR) << "确认分配 查询车位信息失败 " << error.to_string();
	}
	else if (!t_confirm_space.has_car_info())
	{
		t_error.set_error_code(PARKSPACE_ALLOCATOR_RELEASE_FAILED);
		t_error.set_error_level(message::Error_level::MAJOR_ERROR);
		LOG(WARNING) << "传入待确认车位无车辆信息";
	}
	else
	{
		//校验车位状态是否为被锁定
		if (t_confirm_space.parkingspace_status() != message::Parkspace_status::eParkspace_locked)
		{
			t_error.set_error_code(DB_QUERY_DATA_FAILED);
			t_error.set_error_level(message::Error_level::MINOR_ERROR);
			t_error.set_error_description("查询车位状态错误");
			LOG(ERROR) << "确认分配 查询车位状态错误 " << error.to_string();
		}
		else
		{
			//修改车位状态为占用
			t_confirm_space.set_parkingspace_status(message::Parkspace_status::eParkspace_occupied);
			error = m_parkspace_operating_function.update_parkspace_data(t_confirm_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
			{
				//修改车辆状态为已入库
				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)
				{
					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();
				}
				t_error.set_error_code(SUCCESS);
				t_error.set_error_level(message::Error_level::NORMAL);
				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 )
				{
					t_error.set_error_code(error.get_error_code());
					t_error.set_error_level((message::Error_level) error.get_error_level());
					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 )
				{
					t_error.set_error_code(error.get_error_code());
					t_error.set_error_level((message::Error_level) error.get_error_level());
					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 )
				{
					t_error.set_error_code(error.get_error_code());
					t_error.set_error_level((message::Error_level) error.get_error_level());
					LOG(ERROR) << "更新停车记录ID失败: " << error.to_string();
				}
			}
		}
	}
	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.mutable_confirm_alloc_space_info()->CopyFrom(t_confirm_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;
}