puai_dispatch/dispatch/dispatch_manager.cpp

//
// Created by huli on 2020/7/20.
//

#include "dispatch_manager.h"
#include "../tool/proto_tool.h"

#include <cstdlib>

Dispatch_manager::Dispatch_manager()
{
	m_dispatch_manager_status = E_DISPATCH_MANAGER_UNKNOW;
	m_dispatch_manager_id = -1;

	m_catcher_size = 0;
	m_carrier_size = 0;
	m_passageway_size = 0;

	m_process_thread_queue = nullptr;
	m_dispatch_manager_thread = nullptr;

	mpp_space_lock = nullptr;
	m_space_lock_rows = 0;
	m_space_lock_columns = 0;
	m_space_lock_total = 0;
}

Dispatch_manager::~Dispatch_manager()
{
	dispatch_manager_uninit();
}



//调度管理 初始化
Error_manager Dispatch_manager::dispatch_manager_init(int dispatch_manager_id)
{
	m_dispatch_manager_id = dispatch_manager_id;
	return  dispatch_manager_init_from_protobuf(DISPATCH_DEVICE_PARAMETER_PATH);
}

//调度管理 初始化
Error_manager Dispatch_manager::dispatch_manager_init()
{
	return  dispatch_manager_init_from_protobuf(DISPATCH_DEVICE_PARAMETER_PATH);
}

//初始化 调度管理 模块。从文件读取
Error_manager Dispatch_manager::dispatch_manager_init_from_protobuf(std::string prototxt_path)
{
	Dispatch_proto::Dispatch_device_parameter_all t_dispatch_device_parameter_all;
	if(!  proto_tool::read_proto_param(prototxt_path,t_dispatch_device_parameter_all) )
	{
		return Error_manager(DISPATCH_MANAGER_READ_PROTOBUF_ERROR,MINOR_ERROR,
							 "Dispatch_manager read_proto_param  failed");
	}
	return dispatch_manager_init_from_protobuf(t_dispatch_device_parameter_all);
}
//初始化 调度管理 模块。从protobuf读取
Error_manager Dispatch_manager::dispatch_manager_init_from_protobuf(Dispatch_proto::Dispatch_device_parameter_all& dispatch_device_parameter_all)
{
	LOG(INFO) << " ----Dispatch_manager::dispatch_manager_init_from_protobuf----- "<< this;

	Error_manager t_error;
	m_catcher_size = dispatch_device_parameter_all.catcher_parameters_size();
	for (int i = 0; i < m_catcher_size; ++i)
	{
		std::shared_ptr<Dispatch_device_base> tp_dispatch_device_base(new Catcher);
		Catcher* tp_catcher = (Catcher*)tp_dispatch_device_base.get();
		int t_id = dispatch_device_parameter_all.catcher_parameters(i).id();
		int t_key = dispatch_device_parameter_all.catcher_parameters(i).key();
		tp_catcher->dispatch_device_base_init(t_id, t_key);
		m_catcher_map[t_id] = tp_dispatch_device_base;
	}

	m_carrier_size = dispatch_device_parameter_all.carrier_parameters_size();
	for (int i = 0; i < m_carrier_size; ++i)
	{
		std::shared_ptr<Dispatch_device_base> tp_dispatch_device_base(new Carrier);
		Carrier* tp_carrier = (Carrier*)tp_dispatch_device_base.get();

		int t_id = dispatch_device_parameter_all.carrier_parameters(i).id();
		int t_key = dispatch_device_parameter_all.carrier_parameters(i).key();
		tp_carrier->dispatch_device_base_init(t_id, t_key);
		m_carrier_map[t_id] = tp_dispatch_device_base;
	}

	m_passageway_size = dispatch_device_parameter_all.passageway_parameters_size();
	for (int i = 0; i < m_passageway_size; ++i)
	{
		std::shared_ptr<Dispatch_device_base> tp_dispatch_device_base(new Passageway);
		Passageway* tp_passageway = (Passageway*)tp_dispatch_device_base.get();
		int t_id = dispatch_device_parameter_all.passageway_parameters(i).id();
		int t_key = dispatch_device_parameter_all.passageway_parameters(i).key();
		tp_passageway->dispatch_device_base_init(t_id, t_key);
		m_passageway_map[t_id] = tp_dispatch_device_base;
	}

	m_space_lock_rows = dispatch_device_parameter_all.parkspace_number().rows();
	m_space_lock_columns = dispatch_device_parameter_all.parkspace_number().columns();
	m_space_lock_total = dispatch_device_parameter_all.parkspace_number().total();
	mpp_space_lock = new space_device*[m_space_lock_rows];
	for (int i = 0; i < m_space_lock_rows; ++i)
	{
		mpp_space_lock[i] = new space_device[m_space_lock_columns];
		for (int j = 0; j < m_space_lock_columns; ++j)
		{
			//注意了, 这里一定要初始化为-1, 因为设备id=0 是有效设备
			mpp_space_lock[i][j].m_catcher_id = -1;
			mpp_space_lock[i][j].m_carrier_id = -1;
		}
	}

	//等待和plc建立通信后, 标定初始位置, 并加锁. (初始位置可能不标准, 要把左右的都加锁)
//	auto t_time = std::chrono::system_clock::now();
//	bool t_flag = false;
//	int t_rows_index = 0;
//	int t_columns_index = 0;
//	while ( std::chrono::system_clock::now() - t_time < std::chrono::seconds(5) || t_flag == false)
//	{
//		t_flag = true;
//		//先判断搬运器的
//
//		for (auto iter = m_catcher_map.begin(); iter != m_catcher_map.end(); ++iter)
//		{
//			Catcher* tp_catcher = (Catcher*)iter->second.get();
//			int coordinates_id = tp_catcher->m_actual_coordinates_id;
//			if ( coordinates_id == 0 )
//			{
//				t_flag = false;
//			}
//			else if(coordinates_id>0 && coordinates_id<=dispatch_device_parameter_all.parkspace_number().total())
//			{
//				t_rows_index = coordinates_id/columns;
//				t_columns_index = coordinates_id%columns;
//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
//				t_rows_index = (coordinates_id+1)/columns;
//				t_columns_index = (coordinates_id+1)%columns;
//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
//				t_rows_index = (coordinates_id-1)/columns;
//				t_columns_index = (coordinates_id-1)%columns;
//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
//			}
//			else if ( coordinates_id>PASSAGEWAY_ID_BASE )
//			{
//				coordinates_id
//			}
//		}
//		std::this_thread::sleep_for(std::chrono::microseconds(1));
//	}
//	if ( t_flag == false )
//	{
//	    return Error_manager(Error_code::DISPATCH_MANAGER_SPACE_LOCK_ERROR, Error_level::MINOR_ERROR,
//	    					" Dispatch_manager::dispatch_manager_init_from_protobuf error ");
//	}

	std::cout << " huli test :::: " << " m_catcher_size = " << m_catcher_size << std::endl;
	std::cout << " huli test :::: " << " m_catcher_map.size() = " << m_catcher_map.size() << std::endl;
	std::cout << " huli test :::: " << " m_carrier_size = " << m_carrier_size << std::endl;
	std::cout << " huli test :::: " << " m_carrier_map.size() = " << m_carrier_map.size() << std::endl;
	std::cout << " huli test :::: " << " m_passageway_size = " << m_passageway_size << std::endl;
	std::cout << " huli test :::: " << " m_passageway_map.size() = " << m_passageway_map.size() << std::endl;

	std::cout << " huli test :::: " << " m_space_lock_rows = " << m_space_lock_rows << std::endl;
	std::cout << " huli test :::: " << " m_space_lock_columns = " << m_space_lock_columns << std::endl;

	//调度管理 设备复位
	t_error = dispatch_manager_device_reset();
	if ( t_error != Error_code::SUCCESS )
	{
		return t_error;
	}

	//创建线程池
	if (m_process_thread_queue == nullptr) {
		m_process_thread_queue = tq::TQFactory::CreateDefaultQueue();
		m_process_thread_queue->Start(48);
	}


	m_dispatch_manager_status = E_DISPATCH_MANAGER_READY;
	return Error_code::SUCCESS;
}

//调度管理 反初始化
Error_manager Dispatch_manager::dispatch_manager_uninit()
{
	if (m_dispatch_manager_thread)
	{
		m_dispatch_manager_condition.kill_all();
	}
	if (m_dispatch_manager_thread)
	{
		m_dispatch_manager_thread->join();
		delete m_dispatch_manager_thread;
		m_dispatch_manager_thread = NULL;
	}

	//等待线程池完成
	if(m_process_thread_queue!=nullptr) {
		m_process_thread_queue->WaitForFinish();
		m_process_thread_queue->Stop();
		m_process_thread_queue = nullptr;
	}

	m_dispatch_manager_status = E_DISPATCH_MANAGER_UNKNOW;
	m_dispatch_manager_id = -1;


//	for (int i = 0; i < m_catcher_size; ++i)
//	{
//		m_catcher_vector[i]->dispatch_device_base_uninit();
//		delete(m_catcher_vector[i]);
//	}
//	m_catcher_size = 0;
//	m_catcher_vector.clear();
//
//	for (int i = 0; i < m_carrier_size; ++i)
//	{
//		m_carrier_vector[i]->dispatch_device_base_uninit();
//		delete(m_carrier_vector[i]);
//	}
//	m_carrier_size = 0;
//	m_carrier_vector.clear();
//
//	for (int i = 0; i < m_passageway_size; ++i)
//	{
//		m_passageway_vector[i]->dispatch_device_base_uninit();
//		delete(m_passageway_vector[i]);
//	}
//	m_passageway_size = 0;
//	m_passageway_vector.clear();


	return Error_code::SUCCESS;
}

//调度管理 设备复位
Error_manager Dispatch_manager::dispatch_manager_device_reset()
{
	//以后再写
	return Error_code::SUCCESS;
}

//对外的接口函数，负责接受并处理任务单，
Error_manager Dispatch_manager::execute_task(Dispatch_manager::Dispatch_motion_direction dispatch_motion_direction)
{
	return Error_code::SUCCESS;
//	std::this_thread::sleep_for(std::chrono::seconds(rand()%3+3));

	if ( dispatch_motion_direction == E_PICKUP_CAR )
	{
		return Error_code::SUCCESS;
	}

//	return Error_code::SUCCESS;

//	srand(0);
	unsigned int t_probability = rand();

	if ( t_probability%100 >=20 )
	{
		return Error_code::SUCCESS;
	}
	else
	{
		return Error_manager(Error_code::ERROR, Error_level::MINOR_ERROR,
							 " Dispatch_manager::execute_task() error ");
	}
}

//检查能否执行消息指令
Error_manager Dispatch_manager::check_execute_msg(Communication_message* p_msg)
{
	Error_manager t_error = Dispatch_manager::get_instance_references().check_status();
	if ( t_error == Error_code::SUCCESS )
	{
		return Error_code::SUCCESS;
	}
	else if (t_error.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
	{
		std::cout << "Dispatch_manager   _is_busy , " << std::endl;
		//返回繁忙之后, 通信模块1秒后再次调用check
		return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
	}

	switch ( p_msg->get_message_type() )
	{
		case Communication_message::Message_type::eDispatch_request_msg:
		{
			message::Dispatch_request_msg t_dispatch_request_msg;
			//针对消息类型, 对消息进行二次解析
			if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
			{
				//创建一条答复消息
				message::Dispatch_response_msg t_dispatch_response_msg;
				t_dispatch_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_response_msg);
				t_dispatch_response_msg.mutable_base_info()->set_timeout_ms(5000);
				t_dispatch_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_manager);
				t_dispatch_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);

				t_dispatch_response_msg.set_command_key(t_dispatch_request_msg.command_key());
				t_dispatch_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
				t_dispatch_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
				t_dispatch_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());

				std::string t_msg = t_dispatch_response_msg.SerializeAsString();
				System_communication::get_instance_references().encapsulate_msg(t_msg);
				LOG(INFO) << " System_executor::check_execute_msg executer status error "<< this;
				return t_error;
			}
			else
			{
				LOG(INFO) << " System_executor::check_executer Second analysis ERROR "<< this;
				return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
									 " message::Measure_request_msg  ParseFromString error ");
			}
		}
		case Communication_message::Message_type::eDispatch_plan_response_msg:
		{
			return Error_code::SUCCESS;
			break;
		}
		case Communication_message::Message_type::eDispatch_control_request_msg:
		{
			return Error_code::SUCCESS;
			break;
		}
		default :
			//无效的消息,
			return Error_manager(Error_code::INVALID_MESSAGE, Error_level::NEGLIGIBLE_ERROR,
								 " INVALID_MESSAGE error ");
			break;
	}
}
//检查状态
Error_manager Dispatch_manager::check_status()
{
	if ( m_dispatch_manager_status == E_DISPATCH_MANAGER_READY )
	{
		return Error_code::SUCCESS;
	}
	else if ( m_dispatch_manager_status == E_DISPATCH_MANAGER_STORE || m_dispatch_manager_status == E_DISPATCH_MANAGER_STORE )
	{
		return Error_manager(Error_code::DISPATCH_MANAGER_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
							 " Dispatch_manager::check_status() error ");
	}
	else
	{
		return Error_manager(Error_code::DISPATCH_MANAGER_STATUS_ERROR, Error_level::MINOR_ERROR,
							 " Dispatch_manager::check_status() error ");
	}
	return Error_code::SUCCESS;
}

//调度模块 //执行搬运请求(主控->调度管理)
Error_manager Dispatch_manager::execute_for_dispatch_request_msg(message::Dispatch_request_msg& dispatch_request_msg)
{
	LOG(INFO) << " ---Dispatch_manager::execute_for_dispatch_request_msg--- "<< dispatch_request_msg.DebugString() << " "<< this;
	LOG(INFO) << " dispatch_request_msg->m_command_key =  "<<dispatch_request_msg.command_key()<< "   "<< this;

	Error_manager t_error;
	//创建调度流程
	Dispatch_process * tp_dispatch_process(new Dispatch_process);
	t_error = tp_dispatch_process->Dispatch_process_init(dispatch_request_msg);
	if ( t_error != Error_code::SUCCESS )
	{
		delete(tp_dispatch_process);
		return t_error;
	}

	{//加锁
		std::unique_lock<std::mutex> t_lock(m_lock);
		//流程缓存到map
		if (tp_dispatch_process->m_dispatch_process_type ==
			Dispatch_process::Dispatch_process_type::DISPATCH_PROCESS_STORE)
		{
			m_process_store_list.push_back(tp_dispatch_process);
			//这里就不查重了, 需要主控保证不会重复发送...

//			if (m_key_to_dispatch_process_store_map.find(tp_dispatch_process->m_command_key) !=
//				m_key_to_dispatch_process_store_map.end())
//			{
//				t_error = Error_manager(Error_code::DISPATCH_PROCESS_COMMAND_KEY_REPEAT, Error_level::MINOR_ERROR,
//										" tp_dispatch_process->m_command_key is repeat ");
//			}
//			else
//			{
//				m_key_to_dispatch_process_store_map[tp_dispatch_process->m_command_key] = tp_dispatch_process;
//			}
		}
		else if (tp_dispatch_process->m_dispatch_process_type ==
				 Dispatch_process::Dispatch_process_type::DISPATCH_PROCESS_PICKUP)
		{
			m_process_pickup_list.push_back(tp_dispatch_process);
			//这里就不查重了, 需要主控保证不会重复发送...

//			if (m_key_to_dispatch_process_pickup_map.find(tp_dispatch_process->m_command_key) !=
//				m_key_to_dispatch_process_pickup_map.end())
//			{
//				t_error = Error_manager(Error_code::DISPATCH_PROCESS_COMMAND_KEY_REPEAT, Error_level::MINOR_ERROR,
//										" tp_dispatch_process->m_command_key is repeat ");
//			}
//			else
//			{
//				m_key_to_dispatch_process_pickup_map[tp_dispatch_process->m_command_key] = tp_dispatch_process;
//			}
		}
		else
		{
			t_error = Error_manager(Error_code::DISPATCH_PROCESS_TASK_STATUS_ERROR, Error_level::MINOR_ERROR,
									" tp_dispatch_process->m_dispatch_process_type PARAMRTER ERROR ");
		}
	}

	if ( t_error != Error_code::SUCCESS )
	{
		delete(tp_dispatch_process);
		send_dispatch_response_msg_with_error(dispatch_request_msg, t_error);
		return t_error;
	}
	else
	{
		//把流程添加到 调度线程池里面, 里面的线程池会自动回收调度流程的内存
		m_process_thread_queue->AddTask(tp_dispatch_process);
	}

	return Error_code::SUCCESS;
}
//调度模块 答复数据异常
Error_manager Dispatch_manager::send_dispatch_response_msg_with_error(message::Dispatch_request_msg &dispatch_request_msg, Error_manager error)
{
	message::Dispatch_response_msg t_dispatch_response_msg;
	t_dispatch_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_response_msg);
	t_dispatch_response_msg.mutable_base_info()->set_timeout_ms(dispatch_request_msg.base_info().timeout_ms());
	t_dispatch_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_manager);
	t_dispatch_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
	t_dispatch_response_msg.set_command_key(dispatch_request_msg.command_key());

	t_dispatch_response_msg.mutable_error_manager()->set_error_code(error.get_error_code());
	t_dispatch_response_msg.mutable_error_manager()->set_error_level((message::Error_level)error.get_error_level());
	t_dispatch_response_msg.mutable_error_manager()->set_error_description(error.get_error_description(), error.get_description_length());

	System_communication::get_instance_references().encapsulate_msg(t_dispatch_response_msg.SerializeAsString());
	return Error_code::SUCCESS;
}

//调度模块 //调度总规划的答复(调度算法->调度管理)
Error_manager Dispatch_manager::execute_for_dispatch_plan_response_msg(message::Dispatch_plan_response_msg &dispatch_plan_response_msg)
{
	LOG(INFO) << " ---Dispatch_manager::execute_for_dispatch_plan_response_msg--- "<< this;
	LOG(INFO) << " dispatch_plan_response_msg->m_command_key =  "<<dispatch_plan_response_msg.command_key()<< "   "<< this;

	Error_manager t_error;
	std::unique_lock<std::mutex> t_lock(m_lock);

	//使用 command_key 找到对应的流程
	std::string t_command_key = dispatch_plan_response_msg.command_key();
	for (auto iter = m_key_to_dispatch_process_store_map.begin(); iter != m_key_to_dispatch_process_store_map.end(); ++iter)
	{
		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
		{
			t_error = iter->second->check_process_ready() ;
			if ( t_error != Error_code::SUCCESS )
			{
				return t_error;
			}
			//把消息 写入流程
			std::unique_lock<std::mutex> t_lock(iter->second->m_lock);
			iter->second->m_dispatch_plan_response_msg = dispatch_plan_response_msg;
			return Error_code::SUCCESS;
		}
	}
	for (auto iter = m_key_to_dispatch_process_pickup_map.begin(); iter != m_key_to_dispatch_process_pickup_map.end(); ++iter)
	{
		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
		{
			t_error = iter->second->check_process_ready() ;
			if ( t_error != Error_code::SUCCESS )
			{
				return t_error;
			}
			//把消息 写入流程
			std::unique_lock<std::mutex> t_lock(iter->second->m_lock);
			iter->second->m_dispatch_plan_response_msg = dispatch_plan_response_msg;
			return Error_code::SUCCESS;
		}
	}
	return Error_code::SUCCESS;
}
//调度模块 //调度控制的任务请求(调度算法->调度管理)
Error_manager Dispatch_manager::execute_for_dispatch_control_request_msg(message::Dispatch_control_request_msg &dispatch_control_request_msg)
{
	LOG(INFO) << " ---Dispatch_manager::execute_for_dispatch_control_request_msg--- "<< this;
	LOG(INFO) << " dispatch_control_request_msg->m_command_key =  "<<dispatch_control_request_msg.command_key()<< "   "<< this;

	Error_manager t_error;
	std::unique_lock<std::mutex> t_lock(m_lock);

	//使用 command_key 找到对应的流程
	std::string t_command_key = dispatch_control_request_msg.command_key();
	for (auto iter = m_key_to_dispatch_process_store_map.begin(); iter != m_key_to_dispatch_process_store_map.end(); ++iter)
	{
		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
		{
			t_error = iter->second->check_process_ready() ;
			if ( t_error != Error_code::SUCCESS )
			{
				return t_error;
			}
			//把消息 写入流程
			std::unique_lock<std::mutex> t_lock(iter->second->m_lock);
			int t_dispatch_device_type = dispatch_control_request_msg.dispatch_device_type();
			if ( iter->second->m_dispatch_control_node_map.find(t_dispatch_device_type) == iter->second->m_dispatch_control_node_map.end() )
			{
				Dispatch_process::Dispatch_control_node t_dispatch_control_node;
				iter->second->m_dispatch_control_node_map[t_dispatch_device_type] = t_dispatch_control_node;
				iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_status = Dispatch_process::Dispatch_control_status::DISPATCH_CONTROL_READY;
			}
			iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_request_msg = dispatch_control_request_msg;
//			iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_status = Dispatch_process::Dispatch_control_status::DISPATCH_CONTROL_READY;
			return Error_code::SUCCESS;
		}
	}
	for (auto iter = m_key_to_dispatch_process_pickup_map.begin(); iter != m_key_to_dispatch_process_pickup_map.end(); ++iter)
	{
		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
		{
			t_error = iter->second->check_process_ready() ;
			if ( t_error != Error_code::SUCCESS )
			{
				return t_error;
			}
			//把消息 写入流程
			std::unique_lock<std::mutex> t_lock(iter->second->m_lock);
			int t_dispatch_device_type = dispatch_control_request_msg.dispatch_device_type();
			if ( iter->second->m_dispatch_control_node_map.find(t_dispatch_device_type) == iter->second->m_dispatch_control_node_map.end() )
			{
				Dispatch_process::Dispatch_control_node t_dispatch_control_node;
				iter->second->m_dispatch_control_node_map[t_dispatch_device_type] = t_dispatch_control_node;
				iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_status = Dispatch_process::Dispatch_control_status::DISPATCH_CONTROL_READY;
			}
			iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_request_msg = dispatch_control_request_msg;
//			iter->second->m_dispatch_control_node_map[t_dispatch_device_type].m_dispatch_control_status = Dispatch_process::Dispatch_control_status::DISPATCH_CONTROL_READY;
			return Error_code::SUCCESS;
		}
	}
	return Error_code::SUCCESS;
}

//定时发送 调度管理的状态
Error_manager Dispatch_manager::encapsulate_send_dispatch_manager_status()
{
	Error_manager t_error;

	int t_dispatch_manager_id = get_dispatch_manager_id();
	std::string t_msg;

	//创建一条 调度管理总管理的状态
	message::Dispatch_manager_status_msg t_dispatch_manager_status_msg;
	t_dispatch_manager_status_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_manager_status_msg);
	t_dispatch_manager_status_msg.mutable_base_info()->set_timeout_ms(5000);
	t_dispatch_manager_status_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_manager);
	t_dispatch_manager_status_msg.mutable_base_info()->set_receiver(message::Communicator::eEmpty);

	t_dispatch_manager_status_msg.set_dispatch_id(t_dispatch_manager_id);
	Dispatch_manager::Dispatch_manager_status t_dispatch_manager_status = get_dispatch_manager_status();
	t_dispatch_manager_status_msg.set_dispatch_manager_status((message::Dispatch_manager_status)t_dispatch_manager_status);

	for (auto iter = m_catcher_map.begin(); iter != m_catcher_map.end(); ++iter)
	{
		Catcher* tp_catcher = (Catcher*)iter->second.get();
		message::Catcher_data * tp_catcher_data = t_dispatch_manager_status_msg.mutable_catcher_data_map()->Add();

		switch ( tp_catcher->get_device_id() )
		{
			case 0:
			{
				tp_catcher_data->set_dispatch_device_type(message::Dispatch_device_type::ROBOT_1);
				break;
			}
			case 1:
			{
				tp_catcher_data->set_dispatch_device_type(message::Dispatch_device_type::ROBOT_2);
				break;
			}
			default:
			{

				break;
			}
		}
		if ( tp_catcher->get_dispatch_device_status() >= Dispatch_device_base::Dispatch_device_status::DISPATCH_DEVICE_BUSY &&
			 tp_catcher->get_dispatch_device_status() <= Dispatch_device_base::Dispatch_device_status::DISPATCH_DEVICE_THREE_LEVEL_WORK)
		{
			tp_catcher_data->set_dispatch_device_status(message::Dispatch_device_status::DISPATCH_DEVICE_BUSY);

		}
		else
		{
			tp_catcher_data->set_dispatch_device_status((message::Dispatch_device_status)tp_catcher->get_dispatch_device_status());
		}

		tp_catcher_data->set_device_id(tp_catcher->get_device_id());
		tp_catcher_data->set_actual_device_status((message::Hardware_device_status)tp_catcher->m_actual_device_status);
		tp_catcher_data->set_actual_load_status((message::Load_status)tp_catcher->m_actual_load_status);


		tp_catcher_data->set_actual_coordinates_id(tp_catcher->m_actual_coordinates_id);
		tp_catcher_data->set_actual_x(tp_catcher->m_actual_x);
		tp_catcher_data->set_actual_y(tp_catcher->m_actual_y);
		tp_catcher_data->set_actual_b(tp_catcher->m_actual_b);
		tp_catcher_data->set_actual_z(tp_catcher->m_actual_z);
		tp_catcher_data->set_actual_d1(tp_catcher->m_actual_d1);
		tp_catcher_data->set_actual_d2(tp_catcher->m_actual_d2);
		tp_catcher_data->set_actual_clamp_motion1((message::Clamp_motion)tp_catcher->m_actual_clamp_motion1);
		tp_catcher_data->set_actual_clamp_motion2((message::Clamp_motion)tp_catcher->m_actual_clamp_motion2);
		tp_catcher_data->set_actual_clamp_motion3((message::Clamp_motion)tp_catcher->m_actual_clamp_motion3);
		tp_catcher_data->set_actual_clamp_motion4((message::Clamp_motion)tp_catcher->m_actual_clamp_motion4);

		std::string t_actual_error_code((char*)tp_catcher->m_actual_error_code, 50);
		tp_catcher_data->set_actual_error_code(t_actual_error_code);
		std::string t_actual_warning_code((char*)tp_catcher->m_actual_warning_code, 50);
		tp_catcher_data->set_actual_error_code(t_actual_warning_code);
		tp_catcher_data->set_actual_error_code(tp_catcher->m_actual_error_description);
	}
	for (auto iter = m_carrier_map.begin(); iter != m_carrier_map.end(); ++iter)
	{
		Carrier* tp_carrier = (Carrier*)iter->second.get();
		message::Carrier_data * tp_carrier_data = t_dispatch_manager_status_msg.mutable_carrier_data_map()->Add();

		switch ( tp_carrier->get_device_id() )
		{
			case 0:
			{
				tp_carrier_data->set_dispatch_device_type(message::Dispatch_device_type::CARRIER_1);
				break;
			}
			case 1:
			{
				tp_carrier_data->set_dispatch_device_type(message::Dispatch_device_type::CARRIER_2);
				break;
			}
			case 2:
			{
				tp_carrier_data->set_dispatch_device_type(message::Dispatch_device_type::CARRIER_3);
				break;
			}
			default:
			{

				break;
			}
		}
		if ( tp_carrier->get_dispatch_device_status() >= Dispatch_device_base::Dispatch_device_status::DISPATCH_DEVICE_BUSY &&
			 tp_carrier->get_dispatch_device_status() <= Dispatch_device_base::Dispatch_device_status::DISPATCH_DEVICE_THREE_LEVEL_WORK)
		{
			tp_carrier_data->set_dispatch_device_status(message::Dispatch_device_status::DISPATCH_DEVICE_BUSY);

		}
		else
		{
			tp_carrier_data->set_dispatch_device_status((message::Dispatch_device_status)tp_carrier->get_dispatch_device_status());
		}
		tp_carrier_data->set_device_id(tp_carrier->get_device_id());
		tp_carrier_data->set_actual_device_status((message::Hardware_device_status)tp_carrier->m_actual_device_status);
		tp_carrier_data->set_actual_load_status((message::Load_status)tp_carrier->m_actual_load_status);

		tp_carrier_data->set_actual_coordinates_id(tp_carrier->m_actual_coordinates_id);
		tp_carrier_data->set_actual_x(tp_carrier->m_actual_x);
		tp_carrier_data->set_actual_y(tp_carrier->m_actual_y);
		tp_carrier_data->set_actual_z(tp_carrier->m_actual_z);
		tp_carrier_data->set_actual_y1(tp_carrier->m_actual_y1);
		tp_carrier_data->set_actual_y2(tp_carrier->m_actual_y2);
		tp_carrier_data->set_actual_clamp_motion1((message::Clamp_motion)tp_carrier->m_actual_clamp_motion1);
		tp_carrier_data->set_actual_clamp_motion2((message::Clamp_motion)tp_carrier->m_actual_clamp_motion2);
		tp_carrier_data->set_actual_small_sports_car_motion((message::Small_sports_car_motion)tp_carrier->m_actual_small_sports_car_motion);
		tp_carrier_data->set_actual_joint_motion_x1((message::Joint_motion)tp_carrier->m_actual_joint_motion_x1);
		tp_carrier_data->set_actual_joint_motion_x2((message::Joint_motion)tp_carrier->m_actual_joint_motion_x2);

		std::string t_actual_error_code((char*)tp_carrier->m_actual_error_code, 50);
		tp_carrier_data->set_actual_error_code(t_actual_error_code);
		std::string t_actual_warning_code((char*)tp_carrier->m_actual_warning_code, 50);
		tp_carrier_data->set_actual_error_code(t_actual_warning_code);
		tp_carrier_data->set_actual_error_code(tp_carrier->m_actual_error_description);
	}


	t_msg = t_dispatch_manager_status_msg.SerializeAsString();
	System_communication::get_instance_references().encapsulate_msg(t_msg);
//	std::cout << " huli test :::: " << " 12312312312312 = " << t_dispatch_manager_status_msg.DebugString() << std::endl;
//	std::cout << " huli test :::: " << " 123123ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg12312312 = " << 123 << std::endl;

	return Error_code::SUCCESS;
}

//在流程的map 里面释放指定的流程
Error_manager Dispatch_manager::release_dispatch_process(std::string command_key)
{
	std::unique_lock<std::mutex> t_lock(m_lock);

	auto iter1 = m_key_to_dispatch_process_store_map.find(command_key);
	if ( iter1 != m_key_to_dispatch_process_store_map.end())
	{
		m_key_to_dispatch_process_store_map.erase(iter1);
	}

	auto iter2 = m_key_to_dispatch_process_pickup_map.find(command_key);
	if ( iter2 != m_key_to_dispatch_process_pickup_map.end())
	{
		m_key_to_dispatch_process_pickup_map.erase(iter2);
	}
	return Error_code::SUCCESS;
}








Dispatch_manager::Dispatch_manager_status Dispatch_manager::get_dispatch_manager_status()
{
	return m_dispatch_manager_status;
}

int Dispatch_manager::get_dispatch_manager_id()
{
	return m_dispatch_manager_id;
}
void Dispatch_manager::set_dispatch_manager_id(int dispatch_manager_id)
{
	m_dispatch_manager_id = dispatch_manager_id;
}

void Dispatch_manager::set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
}
void Dispatch_manager::set_space_lock_for_catcher(int space_rows, int space_columns, int catcher_id)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
}
void Dispatch_manager::set_space_lock_for_carrier(int space_rows, int space_columns, int carrier_id)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
}
void Dispatch_manager::set_space_lock(int space_id, int catcher_id, int carrier_id)
{
	int space_rows = (space_id-1) / m_space_lock_columns;
	int space_columns = (space_id-1) % m_space_lock_columns;
	set_space_lock(space_rows, space_columns, catcher_id, carrier_id);
}
void Dispatch_manager::set_space_lock_for_catcher(int space_id, int catcher_id)
{
	int space_rows = (space_id-1) / m_space_lock_columns;
	int space_columns = (space_id-1) % m_space_lock_columns;
	set_space_lock_for_catcher(space_rows, space_columns, catcher_id);
}
void Dispatch_manager::set_space_lock_for_carrier(int space_id, int carrier_id)
{
	int space_rows = (space_id-1) / m_space_lock_columns;
	int space_columns = (space_id-1) % m_space_lock_columns;
	set_space_lock_for_carrier(space_rows, space_columns, carrier_id);
}