include/tool/error_code.hpp

//Error_code是错误码的底层通用模块，
//功能：用作故障分析和处理。

//用法：所有的功能接口函数return错误管理类，
//然后上层判断分析错误码，并进行故障处理。
#pragma once

#include <string>
#include <string.h>
#include<iostream>
#include <stdio.h>	/* vsnprintf与vsprintf */
#include <stdarg.h>	/* va... */

#define MAIN_TEST 1
//#define PROCESS_TEST 1
//#define TIME_TEST 1

#define PLC_S7_COMMUNICATION 1    //是否开启plc的通信
#define WAIT_PLC_RESPONSE 1        //是否等待plc的答复
#define MEASURE_TO_PLC_CORRECTION 1        //修正感测数据

//错误管理类转化为字符串 的前缀，固定长度为58
//这个是由显示格式来确定的，如果要修改格式或者 Error_code长度超过8位，Error_level长度超过2位，折需要重新计算
#define ERROR_NAMAGER_TO_STRING_FRONT_LENGTH   58
#define DESCRIPTION_BUF_SIZE 1024
//进程加锁的状态，
enum Lock_status {
    UNLOCK = 0,
    LOCK = 1,
};

//设备使能状态，
enum Able_status {
    UNABLE = 0,
    ENABLE = 1,
};

//数据是否为空
enum Empty_status {
    NON_EMPTY = 0,
    EMPTY = 1,
};


//错误码的枚举，用来做故障分析
enum Error_code {
    //成功，没有错误，默认值0
    SUCCESS = 0x00000000,


    //基本错误码，
    ERROR = 0x00000001,//错误
    PARTIAL_SUCCESS = 0x00000002,//部分成功
    WARNING = 0x00000003,//警告
    FAILED = 0x00000004,//失败

    NODATA = 0x00000010,//没有数据，传入参数容器内部没有数据时，
    INVALID_MESSAGE = 0x00000011, //无效的消息,
    PARSE_FAILED = 0x00000012,//解析失败

    PAUSE = 0x00000013,   //急停
    TASK_CANCEL = 0x00000014,   //任务取消

    DISCONNECT = 0x00000020,   //通讯中断/断开连接
    UNKNOW_STATU = 0x00000021,   //未知状态

    TASK_TIMEOVER = 0x00000020,//任务超时
    RESPONSE_TIMEOUT = 0x00000021,//答复超时

    POINTER_IS_NULL = 0x00000101,//空指针
    PARAMETER_ERROR = 0x00000102,//参数错误，传入参数不符合规范时，
    POINTER_MALLOC_FAIL = 0x00000103,//手动分配内存失败

    CLASS_BASE_FUNCTION_CANNOT_USE = 0x00000201,//基类函数不允许使用，必须使用子类的

    CONTAINER_IS_TERMINATE = 0x00000301,//容器被终止




//    错误码的规范，
//    错误码是int型，32位，十六进制。
//    例如0x12345678
//    12表示功能模块，例如:laser雷达模块               	框架制定
//    34表示文件名称，例如:laser_livox.cpp             框架制定
//    56表示具体的类，例如:class laser_livox           个人制定
//    78表示类的函数，例如:laser_livox::start();       个人制定
//    注：错误码的制定从1开始，不要从0开始，
//        0用作错误码的基数，用来位运算，来判断错误码的范围。







//    laser扫描模块
    LASER_ERROR_BASE = 0x01000000,

//    laser_base基类
    LASER_BASE_ERROR_BASE = 0x01010000,
    LASER_TASK_PARAMETER_ERROR = 0x01010001,   //雷达基类模块, 任务输入参数错误
    LASER_CONNECT_FAILED,                            //雷达基类模块, 连接失败
    LASER_START_FAILED,                                //雷达基类模块, 开始扫描失败
    LASER_CHECK_FAILED,                                //雷达基类模块, 检查失败
    LASER_STATUS_BUSY,                                //雷达基类模块, 状态正忙
    LASER_STATUS_ERROR,                                //雷达基类模块, 状态错误
    LASER_TASK_OVER_TIME,                            //雷达基类模块, 任务超时
    LASER_QUEUE_ERROR,                                //雷达基类模块, 数据缓存错误


//   livox  大疆雷达
    LIVOX_ERROR_BASE = 0x01020000,
    LIVOX_START_FAILE,                                //livox模块，开始扫描失败
    LIVOX_TASK_TYPE_ERROR,                            //livox模块，任务类型错误
    lIVOX_CANNOT_PUSH_DATA,                            //livox模块，不能添加扫描的数据
    lIVOX_CHECK_FAILED,                                //livox模块，检查失败
    lIVOX_STATUS_BUSY,                                //livox模块，状态正忙
    lIVOX_STATUS_ERROR,                                //livox模块，状态错误

    //laser_manager 雷达管理模块
    LASER_MANAGER_ERROR_BASE = 0x01030000,
    LASER_MANAGER_READ_PROTOBUF_ERROR,                //雷达管理模块，读取参数错误
    LASER_MANAGER_STATUS_BUSY,                        //雷达管理模块，状态正忙
    LASER_MANAGER_STATUS_ERROR,                        //雷达管理模块，状态错误
    LASER_MANAGER_TASK_TYPE_ERROR,                    //雷达管理模块，任务类型错误
    LASER_MANAGER_IS_NOT_READY,                        //雷达管理模块，不在准备状态
    LASER_MANAGER_TASK_OVER_TIME,                    //雷达管理模块，任务超时
    LASER_MANAGER_LASER_INDEX_ERRPR,                //雷达管理模块，雷达索引错误，编号错误。
    LASER_MANAGER_LASER_INDEX_REPEAT,                //雷达管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用

//livox_driver 雷达livox驱动模块
    LIVOX_DRIVER_ERROR_BASE = 0x01040000,
    LIVOX_DRIVER_SN_REPEAT,                            //livox驱动模块, 雷达广播码重复
    LIVOX_DRIVER_SN_ERROR,                            //livox驱动模块, 雷达广播码错误
    LIVOX_SKD_INIT_FAILED,                            //livox驱动模块, livox_sdk初始化失败
    LIVOX_DRIVER_NOT_READY,                            //livox驱动模块, livox没有准备好.




    //PLC error code  ...
    PLC_ERROR_BASE = 0x02010000,
    PLC_UNKNOWN_ERROR,                                //plc未知错误
    PLC_EMPTY_TASK,                                    //plc任务为空
    PLC_IP_PORT_ERROR,                                //plc的ip端口错误
    PLC_SLAVE_ID_ERROR,                                //plc的身份id错误
    PLC_CONNECTION_FAILED,                            //PLC连接失败
    PLC_READ_FAILED,                                //plc读取失败
    PLC_WRITE_FAILED,                                //plc写入失败
    PLC_NOT_ENOUGH_DATA_ERROR,                        //PLC没有足够的数据错误



    //locate 定位模块,
    LOCATER_ERROR_BASE = 0x03000000,
    //LASER_MANAGER 定位管理模块
    LOCATER_MANAGER_ERROR_BASE = 0x03010000,
    LOCATER_MANAGER_READ_PROTOBUF_ERROR,                //定位管理模块，读取参数错误
    LOCATER_MANAGER_STATUS_BUSY,                        //定位管理模块，状态正忙
    LOCATER_MANAGER_STATUS_ERROR,                        //定位管理模块，状态错误
    LOCATER_MANAGER_TASK_TYPE_ERROR,                    //定位管理模块，任务类型错误
    LOCATER_MANAGER_IS_NOT_READY,                        //定位管理模块，不在准备状态
    LOCATER_MANAGER_CLOUD_MAP_ERROR,                    //定位管理模块，任务输入点云map的error
    LOCATER_MANAGER_TASK_OVER_TIME,                        //定位管理模块，任务超时


    //Locater  算法模块
    LOCATER_ALGORITHM_ERROR_BASE = 0x03020000,
    LOCATER_TASK_INIT_CLOUD_EMPTY,                        //定位任务初始化点云为空
    LOCATER_TASK_ERROR,                                    //定位任务错误
    LOCATER_TASK_INPUT_CLOUD_UNINIT,                    //定位任务输入点云为空
    LOCATER_INPUT_CLOUD_EMPTY,                            //定位输入点云为空
    LOCATER_YOLO_UNINIT,                                //定位yolo未初始化
    LOCATER_POINTSIFT_UNINIT,                            //定位POINTSIFT未初始化
    LOCATER_3DCNN_UNINIT,                                //定位3DCNN未初始化
    LOCATER_INPUT_YOLO_CLOUD_EMPTY,                        //定位输入yolo点云为空
    LOCATER_Y_OUT_RANGE_BY_PLC,                            //定位超出plc的限制范围
    LOCATER_MEASURE_HEIGHT_CLOUD_UNINIT,                //定位测量高点云未初始化
    LOCATER_MEASURE_HEIGHT_CLOUD_EMPTY,                    //定位测量高点云为空
    LOCATER_INPUT_CLOUD_UNINIT,                            //定位输入点云未初始化


    //point sift from 0x03010100-0x030101FF
    LOCATER_SIFT_ERROR_BASE = 0x03020100,
    LOCATER_SIFT_INIT_FAILED,                            //定位过滤模块，初始化失败
    LOCATER_SIFT_INPUT_CLOUD_UNINIT,                    //定位过滤模块，输入点云未初始化
    LOCATER_SIFT_INPUT_CLOUD_EMPTY,                        //定位过滤模块，输入点云为空
    LOCATER_SIFT_GRID_ERROR,                            //定位过滤模块，筛选网格错误
    LOCATER_SIFT_SELECT_ERROR,                            //定位过滤模块，筛选选择错误
    LOCATER_SIFT_CLOUD_VERY_LITTLE,                        //定位过滤模块，筛选点云很少
    LOCATER_SIFT_CREATE_INPUT_DATA_FAILED,                //定位过滤模块，筛选创建输入数据失败
    LOCATER_SIFT_PREDICT_FAILED,                        //定位过滤模块，预测失败
    LOCATER_SIFT_PREDICT_TIMEOUT,                        //定位过滤模块，预测超时
    LOCATER_SIFT_PREDICT_NO_WHEEL_POINT,                //定位过滤模块，预测结果没有车轮点云
    LOCATER_SIFT_PREDICT_NO_CAR_POINT,                    //定位过滤模块，预测结果没有车身点云

    LOCATER_SIFT_FILTE_OBS_FAILED,                        //定位过滤模块，过滤OBS失败
    LOCATER_SIFT_INPUT_BOX_PARAMETER_FAILED,            //定位过滤模块，输入范围参数错误

//    //yolo 
//    LOCATER_YOLO_ERROR_BASE						=0x03020200,
//    LOCATER_YOLO_DETECT_FAILED,
//    LOCATER_YOLO_DETECT_NO_TARGET,
//    LOCATER_YOLO_PARAMETER_INVALID,
//    LOCATER_YOLO_INPUT_CLOUD_UNINIT,

    //3dcnn from 0x03010300-0x030103FF
    LOCATER_3DCNN_ERROR_BASE = 0x03020300,
    LOCATER_3DCNN_INIT_FAILED,                            //定位3DCNN模块，初始化失败
    LOCATER_3DCNN_INPUT_CLOUD_UNINIT,                    //定位3DCNN模块，输入点云未初始化
    LOCATER_3DCNN_INPUT_CLOUD_EMPTY,                    //定位3DCNN模块，输入点云为空
    LOCATER_3DCNN_INPUT_CLOUD_MAP_ERROR,                //定位3DCNN模块，输入点云的map错误
    LOCATER_3DCNN_PCA_OUT_ERROR,                        //定位3DCNN模块，pca错误
    LOCATER_3DCNN_EXTRACT_RECT_ERROR,                    //定位3DCNN模块，提取矩形错误
    LOCATER_3DCNN_RECT_SIZE_ERROR,                        //定位3DCNN模块，矩形范围错误

    LOCATER_3DCNN_PREDICT_FAILED,                        //定位3DCNN模块，预测失败
    LOCATER_3DCNN_VERIFY_RECT_FAILED_3,                    //定位3DCNN模块，验证矩形失败3
    LOCATER_3DCNN_VERIFY_RECT_FAILED_4,                    //定位3DCNN模块，验证矩形失败4
    LOCATER_3DCNN_KMEANS_FAILED,                        //定位3DCNN模块，k均值失败
    LOCATER_3DCNN_IIU_FAILED,                            //定位3DCNN模块，IIU失败
    LOCATER_3DCNN_PCA_OUT_CLOUD_EMPTY,                    //定位3DCNN模块，pca输出点云为空

    //感测和主控通信
    LOCATER_MSG_TABLE_NOT_EXIST = 0x03030100,
    LOCATER_MSG_RESPONSE_TYPE_ERROR,                                //测量反馈消息类型错误(致命)
    LOCATER_MSG_RESPONSE_INFO_ERROR,
    LOCATER_MSG_REQUEST_CANCELED,
    LOCATER_MSG_REQUEST_INVALID,
    LOCATER_MSG_RESPONSE_HAS_NO_REQUEST,
    LOCATER_MSG_REQUEST_REPEATED,

    //System_manager error from 0x04010000-0x0401FFFF
    SYSTEM_READ_PARAMETER_ERROR = 0x04010100,
    SYSTEM_PARAMETER_ERROR,
    SYSTEM_INPUT_TERMINOR_NO_LASERS,

    //terminor_command_executor.cpp from 0x04010200-0x040102FF
    TERMINOR_NOT_READY = 0x04010200,
    TERMINOR_INPUT_LASER_NULL,
    TERMINOR_NOT_CONTAINS_LASER,
    TERMINOR_INPUT_PLC_NULL,
    TERMINOR_INPUT_LOCATER_NULL,
    TERMINOR_CREATE_WORKING_THREAD_FAILED,
    TERMINOR_FORCE_QUIT,
    TERMINOR_LASER_TIMEOUT,
    TERMINOR_POST_PLC_TIMEOUT,
    TERMINOR_CHECK_RESULTS_ERROR,

    ////Hardware limit from 0x05010000 - 0x0501ffff
    ///railing.cpp from 0x05010100-0x050101ff
    HARDWARE_LIMIT_LEFT_RAILING = 0x05010100,         //左栏杆限制
    HARDWARE_LIMIT_RAILING_PARAMETER_ERROR,
    HARDWARE_LIMIT_RAILING_ERROR,
    HARDWARE_LIMIT_CENTER_X_LEFT,
    HARDWARE_LIMIT_CENTER_X_RIGHT,
    HARDWARE_LIMIT_CENTER_Y_TOP,
    HARDWARE_LIMIT_CENTER_Y_BOTTOM,
    HARDWARE_LIMIT_HEIGHT_OUT_RANGE,
    HARDWARE_LIMIT_ANGLE_OUT_RANGE,
    //termonal_limit from 0x05010200-0x050102ff
    HARDWARE_LIMIT_TERMINAL_LEFT_ERROR,
    HARDWARE_LIMIT_TERMINAL_RIGHT_ERROR,
    HARDWARE_LIMIT_TERMINAL_LR_ERROR,


//万集设备模块，
    WANJI_LIDAR_DEVICE_ERROR_BASE = 0x06080000,//万集设备模块，错误基类
    WANJI_LIDAR_DEVICE_STATUS_BUSY,                                    //万集设备模块，状态正忙
    WANJI_LIDAR_DEVICE_STATUS_ERROR,                                //万集设备模块，状态错误
    WANJI_LIDAR_DEVICE_TASK_TYPE_ERROR,                                //万集设备模块，任务类型错误
    WANJI_LIDAR_DEVICE_TASK_OVER_TIME,                                //万集设备模块，任务超时
    WANJI_LIDAR_DEVICE_NO_CLOUD,                                    //万集设备模块，没有点云
    // velodyne设备模块
    VELODYNE_LIDAR_DEVICE_ERROR_BASE,                                //velodyne设备模块，错误基类
    VELODYNE_LIDAR_DEVICE_STATUS_BUSY,                                    //velodyne设备模块，状态正忙
    VELODYNE_LIDAR_DEVICE_STATUS_ERROR,                                //velodyne设备模块，状态错误
    VELODYNE_LIDAR_DEVICE_TASK_TYPE_ERROR,                                //velodyne设备模块，任务类型错误
    VELODYNE_LIDAR_DEVICE_TASK_OVER_TIME,                                //velodyne设备模块，任务超时
    VELODYNE_LIDAR_DEVICE_NO_CLOUD,                                    //velodyne设备模块，没有点云


    //万集通信wj_lidar error from 0x06010000-0x0601FFFF
    WJ_LIDAR_COMMUNICATION_ERROR_BASE = 0x06010000,
    WJ_LIDAR_COMMUNICATION_UNINITIALIZED,                            //万集通信,未初始化
    WJ_LIDAR_COMMUNICATION_DISCONNECT,                                //万集通信,断连
    WJ_LIDAR_COMMUNICATION_FAULT,                                    //万集通信,故障
    WJ_LIDAR_CONNECT_FAILED,                                        //万集通信,连接失败
    WJ_LIDAR_UNINITIALIZED,                                            //万集通信,未初始化
    WJ_LIDAR_READ_FAILED,                                            //万集通信,读取失败
    WJ_LIDAR_WRITE_FAILED,                                            //万集通信,写入失败
    WJ_LIDAR_GET_CLOUD_TIMEOUT,                                        //万集通信,获取点云超时
    // velodyne通信
    VELODYNE_LIDAR_COMMUNICATION_UNINITIALIZED,                            //velodyne通信,未初始化
    VELODYNE_LIDAR_COMMUNICATION_DISCONNECT,                                //velodyne通信,断连
    VELODYNE_LIDAR_COMMUNICATION_FAULT,                                    //velodyne通信,故障
    VELODYNE_LIDAR_CONNECT_FAILED,                                        //velodyne通信,连接失败
    VELODYNE_LIDAR_UNINITIALIZED,                                            //velodyne通信,未初始化
    VELODYNE_LIDAR_READ_FAILED,                                            //velodyne通信,读取失败
    VELODYNE_LIDAR_WRITE_FAILED,                                            //velodyne通信,写入失败
    VELODYNE_LIDAR_GET_CLOUD_TIMEOUT,                                        //velodyne通信,获取点云超时

    //万集解析 wj lidar protocol error from 0x06020000-0x0602FFFF
    WJ_PROTOCOL_ERROR_BASE = 0x06020000,
    WJ_PROTOCOL_STATUS_BUSY,                                        //万集解析, 状态正忙
    WJ_PROTOCOL_STATUS_ERROR,                                        //万集解析, 状态错误
    WJ_PROTOCOL_INTEGRITY_ERROR,                                    //万集解析, 完整性错误
    WJ_PROTOCOL_PARSE_FAILED,                                        //万集解析, 解析失败
    WJ_PROTOCOL_EMPTY_PACKAGE,                                        //万集解析, 空包
    WJ_PROTOCOL_EXCEED_MAX_SIZE,                                    //万集解析, 超出最大范围

    //万集测量范围 wj region detect error from 0x06030000-0x0603FFFF
    WJ_REGION_ERROR_BASE = 0x06030000,
    WJ_REGION_EMPTY_CLOUD,                                            //万集测量，空点云
    WJ_REGION_EMPTY_NO_WHEEL_INFORMATION,                            //万集测量，没有车轮信息
    WJ_REGION_RECTANGLE_ANGLE_ERROR,                                //万集测量，矩形旋转角错误
    WJ_REGION_RECTANGLE_SIZE_ERROR,                                    //万集测量，矩形大小错误
    WJ_REGION_RECTANGLE_SYMMETRY_ERROR,                                //万集测量，矩形对称错误
    WJ_REGION_CLUSTER_SIZE_ERROR,                                    //万集测量，簇大小错误
    WJ_REGION_CERES_SOLVE_ERROR,                                    //万集测量，优化失败
    //velodyne测量范围
    VELODYNE_REGION_ERROR_BASE,
    VELODYNE_REGION_EMPTY_CLOUD,                                            //velodyne测量，空点云
    VELODYNE_REGION_EMPTY_NO_WHEEL_INFORMATION,                            //velodyne测量，没有车轮信息
    VELODYNE_REGION_RECTANGLE_ANGLE_ERROR,                                //velodyne测量，矩形旋转角错误
    VELODYNE_REGION_RECTANGLE_SIZE_ERROR,                                    //velodyne测量，矩形大小错误
    VELODYNE_REGION_RECTANGLE_SYMMETRY_ERROR,                                //velodyne测量，矩形对称错误
    VELODYNE_REGION_CLUSTER_SIZE_ERROR,                                    //velodyne测量，簇大小错误
    VELODYNE_REGION_CERES_SOLVE_ERROR,                                    //velodyne测量，优化失败
    VELODYNE_REGION_ANGLE_PRECHECK_FAILED,                                    //velodyne测量，rough angle check failed

    //万集管理模块 wj manager error from 0x06040000-0x0604FFFF
    WJ_MANAGER_ERROR_BASE = 0x06040000,
    WJ_MANAGER_UNINITIALIZED,                                    //万集管理模块，未初始化
    WJ_MANAGER_LIDAR_DISCONNECTED,                                //万集管理模块，雷达断链
    WJ_MANAGER_PLC_DISCONNECTED,                                //万集管理模块，plc断链
    WJ_MANAGER_EMPTY_CLOUD,                                        //万集管理模块，空点云
    WJ_MANAGER_READ_PROTOBUF_ERROR,                                //万集管理模块，读取参数错误
    WJ_MANAGER_INIT_ERROR,                                        //万集管理模块，初始化error
    WJ_MANAGER_TASK_TYPE_ERROR,                                    //万集管理模块，任务类型错误
    WJ_MANAGER_STATUS_BUSY,                                        //万集管理模块，状态正忙
    WJ_MANAGER_STATUS_ERROR,                                    //万集管理模块，状态错误
    WJ_MANAGER_LASER_INDEX_ERRPR,                                //万集管理模块，雷达索引错误，编号错误。
    WJ_MANAGER_LASER_INDEX_REPEAT,                                //万集管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用
    WJ_MANAGER_TASK_OVER_TIME,                                    //万集管理模块，任务超时
    VELODYNE_MANAGER_ERROR_BASE,
    VELODYNE_MANAGER_UNINITIALIZED,                                    //velodyne管理模块，未初始化
    VELODYNE_MANAGER_LIDAR_DISCONNECTED,                                //velodyne管理模块，雷达断链
    VELODYNE_MANAGER_EMPTY_CLOUD,                                        //velodyne管理模块，空点云
    VELODYNE_MANAGER_READ_PROTOBUF_ERROR,                                //velodyne管理模块，读取参数错误
    VELODYNE_MANAGER_INIT_ERROR,                                        //velodyne管理模块，初始化error
    VELODYNE_MANAGER_TASK_TYPE_ERROR,                                    //velodyne管理模块，任务类型错误
    VELODYNE_MANAGER_STATUS_BUSY,                                        //velodyne管理模块，状态正忙
    VELODYNE_MANAGER_STATUS_ERROR,                                    //velodyne管理模块，状态错误
    VELODYNE_MANAGER_LASER_INDEX_ERRPR,                                //velodyne管理模块，雷达索引错误，编号错误。
    VELODYNE_MANAGER_LASER_INDEX_REPEAT,                                //velodyne管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用
    VELODYNE_MANAGER_TASK_OVER_TIME,                                    //velodyne管理模块，任务超时

//万集任务模块
    WJ_LIDAR_TASK_ERROR_BASE = 0x06050000,
    WJ_LIDAR_TASK_EMPTY_RESULT,                                    //万集任务模块，空结果
    WJ_LIDAR_TASK_EMPTY_TASK,                                    //万集任务模块，空任务
    WJ_LIDAR_TASK_WRONG_TYPE,                                    //万集任务模块，错误类型
    WJ_LIDAR_TASK_INVALID_TASK,                                    //万集任务模块，无效任务
    WJ_LIDAR_TASK_MEASURE_FAILED,                                //万集任务模块，测量失败

    // 万集滤波
    WJ_FILTER_ERROR_BASE = 0x06060000,
    WJ_FILTER_LACK_OF_RESULT,                                   //万集滤波,结果不足以进行滤波
    WJ_FILTER_FLUCTUATING,                                      //万集滤波,结果波动过大

    //task module, 任务模块  error from 0x10010000-0x1001FFFF
    TASK_MODULE_ERROR_BASE = 0x10010000,
    TASK_TYPE_IS_UNKNOW,
    TASK_NO_RECEIVER,


    //Communication module, 通信模块
    COMMUNICATION_BASE_ERROR_BASE = 0x11010000,
    COMMUNICATION_READ_PROTOBUF_ERROR,                //模块，读取参数错误
    COMMUNICATION_BIND_ERROR,
    COMMUNICATION_CONNECT_ERROR,
    COMMUNICATION_ANALYSIS_TIME_OUT,                                    //解析超时,
    COMMUNICATION_EXCUTER_IS_BUSY,                                        //处理器正忙, 请稍等




    //system module, 系统模块
    SYSTEM_EXECUTOR_ERROR_BASE = 0x12010000,        //系统执行模块,
    SYSTEM_EXECUTOR_PARSE_ERROR,                                        //系统执行模块, 解析消息错误
    SYSTEM_EXECUTOR_STATUS_BUSY,                                        //系统执行模块, 状态正忙
    SYSTEM_EXECUTOR_STATUS_ERROR,                                        //系统执行模块, 状态错误
    SYSTEM_EXECUTOR_CHECK_ERROR,                                        //系统执行模块, 检查错误



    //Dispatch 调度 模块 错误码
    DISPATCH_ERROR_BASE = 0x13000000,

    //Dispatch_manager 调度管理模块 错误码
    DISPATCH_MANAGER_ERROR_BASE = 0x13010000,
    DISPATCH_MANAGER_READ_PROTOBUF_ERROR,                //调度管理模块，读取参数错误
    DISPATCH_MANAGER_STATUS_BUSY,                        //调度管理模块，状态正忙
    DISPATCH_MANAGER_STATUS_ERROR,                        //调度管理模块，状态错误
    DISPATCH_MANAGER_TASK_TYPE_ERROR,                    //调度管理模块，任务类型错误
    DISPATCH_MANAGER_IS_NOT_READY,                        //调度管理模块，不在准备状态
    DISPATCH_MANAGER_SPACE_LOCK_ERROR,                    //调度管理模块，空间锁错误


    DISPATCH_PROCESS_ERROR_BASE = 0x13020000,
    DISPATCH_PROCESS_IS_NOT_READY,                        //调度流程, 不在准备状态
    DISPATCH_PROCESS_DEVICE_TYPE_ERROR,                    //调度流程, 设备类型错误
    DISPATCH_PROCESS_DEVICE_STATUS_ERROR,                //调度流程, 设备状态错误
    DISPATCH_PROCESS_TASK_STATUS_ERROR,                    //调度流程, 任务类型错误
    DISPATCH_PROCESS_COMMAND_KEY_REPEAT,                //调度流程, 唯一码错误
    DISPATCH_PROCESS_INIT_ERROR,                        //调度流程, 初始化错误


    DISPATCH_DEVICE_ERROR_BASE = 0x13030000,
    DISPATCH_DEVICE_READ_PROTOBUF_ERROR,                //调度设备模块，读取参数错误
    DISPATCH_DEVICE_STATUS_BUSY,                        //调度设备模块，状态正忙
    DISPATCH_DEVICE_STATUS_ERROR,                        //调度设备模块，状态错误
    DISPATCH_DEVICE_STATUS_DISCONNECT,                    //调度设备模块，状态断连
    DISPATCH_DEVICE_TASK_TYPE_ERROR,                    //调度设备模块，任务类型错误
    DISPATCH_DEVICE_TASK_OVER_TIME,                        //调度设备模块，任务超时
    DISPATCH_DEVICE_TASK_REPEAT,                        //调度设备模块，任务重复, 任务已经存在
    DISPATCH_DEVICE_IS_NOT_READY,                        //调度设备模块，不在准备状态
    DISPATCH_DEVICE_RESPONS_ERROR,                        //调度设备模块，指令的执行失败
    DISPATCH_DEVICE_TASK_NOTHINGNESS,                    //调度设备模块，任务不存在
    DISPATCH_DEVICE_TASK_LEVEL_ERROR,                    //调度设备模块，任务等级错误


    CARRIER_ERROR_BASE = 0x13040000,
    CARRIER_READ_PROTOBUF_ERROR,                //搬运器模块，读取参数错误
    CARRIER_STATUS_BUSY,                        //搬运器模块，状态正忙
    CARRIER_STATUS_ERROR,                        //搬运器模块，状态错误
    CARRIER_STATUS_DISCONNECT,                    //搬运器模块，状态断连
    CARRIER_TASK_TYPE_ERROR,                    //搬运器模块，任务类型错误
    CARRIER_TASK_OVER_TIME,                        //搬运器模块，任务超时
    CARRIER_IS_NOT_READY,                        //搬运器模块，不在准备状态
    CARRIER_RESPONS_ERROR,                        //搬运器模块，指令的执行失败
    CARRIER_TASK_NOTHINGNESS,                    //搬运器模块，任务不存在
    CARRIER_POSE_ERROR,                            //搬运器模块，姿态错误
    CARRIER_CONRTOL_PARAMETER_ERROR,            //搬运器模块，控制参数错误

    CATCHER_ERROR_BASE = 0x13050000,
    CATCHER_READ_PROTOBUF_ERROR,                //抓取器模块，读取参数错误
    CATCHER_STATUS_BUSY,                        //抓取器模块，状态正忙
    CATCHER_STATUS_ERROR,                        //抓取器模块，状态错误
    CATCHER_STATUS_DISCONNECT,                    //抓取器模块，状态断连
    CATCHER_TASK_TYPE_ERROR,                    //抓取器模块，任务类型错误
    CATCHER_TASK_OVER_TIME,                        //抓取器模块，任务超时
    CATCHER_IS_NOT_READY,                        //抓取器模块，不在准备状态
    CATCHER_RESPONS_ERROR,                        //抓取器模块，指令的执行失败
    CATCHER_TASK_NOTHINGNESS,                    //抓取器模块，任务不存在
    CATCHER_POSE_ERROR,                            //抓取器模块，姿态错误
    CATCHER_CONRTOL_PARAMETER_ERROR,            //抓取器模块，控制参数错误

    PASSAGEWAY_ERROR_BASE = 0x13060000,
    PASSAGEWAY_READ_PROTOBUF_ERROR,                //通道口模块，读取参数错误
    PASSAGEWAY_STATUS_BUSY,                        //通道口模块，状态正忙
    PASSAGEWAY_STATUS_ERROR,                        //通道口模块，状态错误
    PASSAGEWAY_STATUS_DISCONNECT,                    //通道口模块，状态断连
    PASSAGEWAY_TASK_TYPE_ERROR,                    //通道口模块，任务类型错误
    PASSAGEWAY_TASK_OVER_TIME,                        //通道口模块，任务超时
    PASSAGEWAY_IS_NOT_READY,                        //通道口模块，不在准备状态
    PASSAGEWAY_RESPONS_ERROR,                        //通道口模块，指令的执行失败
    PASSAGEWAY_TASK_NOTHINGNESS,                    //通道口模块，任务不存在


    //DISPATCH_COORDINATES module, 通信模块
    DISPATCH_COORDINATES_ERROR_BASE = 0x13060000,
    DISPATCH_COORDINATES_READ_PROTOBUF_ERROR,                //调度坐标模块，读取参数错误
    DISPATCH_COORDINATES_ID_ERROR,                            //调度坐标模块，坐标id错误
    DISPATCH_COORDINATES_PATH_ERROR,                        //调度坐标模块，路径方向错误
    DISPATCH_COORDINATES_CAN_NOT_LOCK,                        //调度坐标模块，不能加锁

    //Dispatch_plc 调度plc模块
    DISPATCH_PLC_ERROR_BASE = 0x13070000,
    DISPATCH_PLC_REQUEST_ERROR,                                //调度plc模块，请求错误
    DISPATCH_PLC_RESPONS_ERROR,                                //调度plc模块，指令的执行失败
    DISPATCH_PLC_STATUS_ERROR,                                //调度plc模块，状态错误
    DISPATCH_PLC_TIME_OUT,                                    //调度plc模块，超时


    //snap7 通信模块 错误码
    SNAP7_ERROR_BASE = 0x1401000,
    SNAP7_READ_PROTOBUF_ERROR,                            //snap7通信模块，读取参数错误
    SNAP7_CONNECT_ERROR,                                //snap7通信模块，连接错误
    SNAP7_DISCONNECT_ERROR,                                //snap7通信模块，断连错误
    SNAP7_READ_ERROR,                                    //snap7通信模块，读取错误
    SNAP7_WRITE_ERROR,                                    //snap7通信模块，写入错误
    SNAP7_ANALYSIS_TIME_OUT,                                    //解析超时,
    SNAP7_EXCUTER_IS_BUSY,                                        //处理器正忙, 请稍等

    TOF3D_VZENSE_DEVICE_INIT_SUCCESS = 0x1501000,
    TOF3D_VZENSE_DEVICE_INIT_FAILED,



    //parkspace allocator，车位分配模块
    PARKSPACE_ALLOCATOR_ERROR_BASE = 0x20010000,
    PARKSPACE_ALLOCATOR_MSG_REQUEST_TYPE_ERROR,    //反馈车位消息类型错误 
    PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR,    //反馈车位消息类型错误
    PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR,            //请求消息解析错误
    PARKSPACE_ALLOCATOR_SPACE_EMPTY,                //空车位异常，车库无车位。或许由模块初始化异常产生
    PARKSPACE_ALLOCATOR_ALLOCATE_FAILED,            //无合适车位，分配失败
    PARKSPACE_ALLOCATOR_SEARCH_FAILED,              //未找到车辆对应车位
    PARKSPACE_ALLOCATOR_RELEASE_FAILED,             //未找到匹配的车位，车位未释放
    PARKSPACE_ALLOCATOR_FORCE_UPDATE_FAILED,        //手动更新失败，未找到匹配车位
    PARKSPACE_ALLOCATOR_PARAM_ERROR,                //传入参数错误
    PARKSPACE_ALLOCATOR_CONFIRM_ALLOC_ERROR,        //确认分配车位错误
    PARKSPACE_ALLOCATOR_CAR_ALREADY_EXIST,          //车辆已存在

    // 数据库操作
    DB_ERROR_BASE = 0x20020000,
    DB_INIT_FAILED,                                    //数据库初始化失败
    DB_CONNECT_FAILED,                              //数据库连接失败
    DB_STATUS_ERROR,                                //数据库状态错误
    DB_MANAGER_STATUS_ERROR,                        //数据库管理状态错误
    DB_INSERT_FAILED,                               //数据库插入失败
    DB_DELETE_FAILED,                               //数据库删除失败
    DB_UPDATE_FAILED,                               //数据库更新失败
    DB_QUERY_FAILED,                                //数据库查询失败
    DB_UNINITIALIZED,                               //数据库外层未初始化
    DB_DISCONNECTED,                                //数据库外层连接失去
    DB_RESULT_SET_EMPTY,                            //数据库外层查询返回结果空指针
    DB_RESULT_SET_PARSE_ERROR,                      //数据库外层查询结果解析失败
    DB_CONNECT_CHANNEL_NOT_FOUND,                    //数据库连接通道未找到
    DB_CONNECT_CHANNEL_NUMBER_ERROR,                //数据库连接通道数量错误
    DB_QUERY_DATA_REPEAT,                            //数据库查询数据重复
    DB_QUERY_NOT_DATA,                                //数据库未查询到数据
    DB_QUERY_DATA_FAILED,                            //数据库查询数据错误
    DB_NOT_QUERY_EMPTY_PARKSPACE,                    //数据库未查询到空车位
    DB_PROTOBUF_ERROR,                                //数据库配置参数读取错误




    //parkspace error code
    PARKSPACE_REQUEST_MSG_TYPE_ERROR = 0x20030000,
    PARKSPACE_ALLOCMSG_RESPONSE_HAS_NO_REQUEST,
    PARKSPACE_SEARCHMSG_RESPONSE_HAS_NO_REQUEST,
    PARKSPACE_RELEASEMSG_RESPONSE_HAS_NO_REQUEST,
    PARKSPACE_ALLOC_REQUEST_INVALID,
    PARKSPACE_SEARCH_REQUEST_INVALID,
    PARKSPACE_RELEASE_REQUEST_INVALID,

    PARKSPACE_ALLOC_REQUEST_REPEATED,
    PARKSPACE_SEARCH_REQUEST_REPEATED,
    PARKSPACE_RELEASE_REQUEST_REPEATED,

    PARKSPACE_ALLOC_RESPONSE_TYPE_ERROR,
    PARKSPACE_SEARCH_RESPONSE_TYPE_ERROR,
    PARKSPACE_RELEASE_RESPONSE_TYPE_ERROR,

    PARKSPACE_ALLOC_RESPONSE_INFO_ERROR,
    PARKSPACE_SEARCH_RESPONSE_INFO_ERROR,
    PARKSPACE_RELEASE_RESPONSE_INFO_ERROR,

    PARKSPACE_ALLOC_REQUEST_CANCELED,
    PARKSPACE_SEARCH_REQUEST_CANCELED,
    PARKSPACE_RELEASE_REQUEST_CANCELED,

    //rabbitmq module, 通信模块  新版通信
    RABBITMQ_BASE_ERROR_BASE = 0x31010000,
    RABBITMQ_READ_PROTOBUF_ERROR,                    //rabbitmq模块，读取PROTO参数错误
    RABBITMQ_AMQP_NEW_CONNECTION_ERROR,                //rabbitmq模块，新建连接状态错误
    RABBITMQ_AMQP_TCP_SOCKET_NEW_ERROR,                //rabbitmq模块，新建socket错误
    RABBITMQ_PROTOBUF_LOSS_ERROR,                    //rabbitmq模块，PROTO缺少数据
    RABBITMQ_AMQP_SOCKET_OPEN_ERROR,                //rabbitmq模块，打开socket错误
    RABBITMQ_AMQP_LOGIN_ERROR,                        //rabbitmq模块，登录服务器错误
    RABBITMQ_AMQP_CHANNEL_OPEN_ERROR,                //rabbitmq模块，打开通道错误
    RABBITMQ_AMQP_QUEUE_BIND_ERROR,                    //rabbitmq模块，绑定队列错误
    RABBITMQ_AMQP_NEW_CONSUME_ERROR,                //rabbitmq模块，新建消费者错误
    RABBITMQ_AMQP_CONSUME_MESSAGE_ERROR,            //rabbitmq模块，接受消息错误
    RABBITMQ_AMQP_BASIC_PUBLISH_ERROR,                //rabbitmq模块，发送消息错误
    RABBITMQ_AMQP_BASIC_ACK_ERROR,                    //rabbitmq模块，确认消息错误


    RABBITMQ_BIND_ERROR,
    RABBITMQ_CONNECT_ERROR,
    RABBITMQ_ANALYSIS_TIME_OUT,                                    //解析超时,
    RABBITMQ_EXCUTER_IS_BUSY,                                        //处理器正忙, 请稍等


};

//错误等级，用来做故障处理
enum Error_level {
//    正常，没有错误，默认值0
    NORMAL = 0,


//    轻微故障,可忽略的故障，NEGLIGIBLE_ERROR
//    提示作用，不做任何处理，不影响代码的流程，
//    用作一些不重要的事件，即使出错也不会影响到系统功能，
//    例如：文件保存错误，等
    NEGLIGIBLE_ERROR = 1,


//    一般故障，MINOR_ERROR
//    用作底层功能函数的错误返回，表示该功能函数执行失败，
//    返回给应用层之后，需要做故障分析和处理，
//    例如：雷达数据传输失败，应用层就需要进行重新扫描，或者重连，或者重置参数等。
    MINOR_ERROR = 2,


//    严重故障，MAJOR_ERROR
//    用作应用层的任务事件的结果，表示该功能模块失败。
//    通常是底层函数返回一般故障之后，应用层无法处理并解决故障，此时就要进行故障升级，
//    从一般故障升级为严重故障，然后进行回退流程，回退已经执行的操作，最终回到故障待机状态。
//    需要外部清除故障，并复位至正常待机状态，才能恢复功能的使用。
//    例如：雷达扫描任务失败，且无法自动恢复。
    MAJOR_ERROR = 3,


//    致命故障，CRITICAL_ERROR
//    系统出现致命错误。导致系统无法正常运行，
//    此时系统应该紧急停机，执行紧急流程，快速停机。
//    此时不允许再执行任何函数和任务指令，防止系统故障更加严重。
//    也不需要做任何错误处理了，快速执行紧急流程。
//    例如：内存错误，进程挂死，关键设备失控，监控设备报警，等
    CRITICAL_ERROR = 4,
};


class Error_manager {
public://外部接口函数
    //构造函数
    Error_manager() {
        m_error_code = SUCCESS;
        m_error_level = NORMAL;
    }

    //拷贝构造
    Error_manager(const Error_manager &error_manager) {
        this->m_error_code = error_manager.m_error_code;
        this->m_error_level = error_manager.m_error_level;
        this->m_error_description = error_manager.m_error_description;
    }

    //赋值构造
    Error_manager(Error_code error_code, Error_level error_level = NORMAL,
                  const char *f = nullptr, ...) {
        va_list arg_ptr;
        char buf[DESCRIPTION_BUF_SIZE];
        va_start(arg_ptr, f);
        vsnprintf(buf, DESCRIPTION_BUF_SIZE, f, arg_ptr);
        va_end(arg_ptr);

        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = std::string(buf);
    }

    //赋值构造
    Error_manager(Error_code error_code, Error_level error_level, std::string error_aggregate_string) {
        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = error_aggregate_string;
    }

    //析构函数
    ~Error_manager() = default;

    //初始化
    void error_manager_init() {
        error_manager_clear_all();
    }

    //初始化
    void error_manager_init(Error_code error_code, Error_level error_level = NORMAL,
                            const char *f = nullptr, ...) {
        va_list arg_ptr;
        char buf[DESCRIPTION_BUF_SIZE];
        va_start(arg_ptr, f);
        vsnprintf(buf, DESCRIPTION_BUF_SIZE, f, arg_ptr);
        va_end(arg_ptr);

        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = std::string(buf);
    }

    //初始化
    void error_manager_init(Error_code error_code, Error_level error_level, std::string error_aggregate_string) {
        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = error_aggregate_string;
    }

    //重置
    void error_manager_reset(Error_code error_code, Error_level error_level = NORMAL,
                             const char *f = nullptr, ...) {
        va_list arg_ptr;
        char buf[DESCRIPTION_BUF_SIZE];
        va_start(arg_ptr, f);
        vsnprintf(buf, DESCRIPTION_BUF_SIZE, f, arg_ptr);
        va_end(arg_ptr);

        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = std::string(buf);
    }

    //重置
    void error_manager_reset(Error_code error_code, Error_level error_level, std::string error_aggregate_string) {
        m_error_code = error_code;
        m_error_level = error_level;
        m_error_description = error_aggregate_string;
    }

    //重置
    void error_manager_reset(const Error_manager &error_manager) {
        this->m_error_code = error_manager.m_error_code;
        this->m_error_level = error_manager.m_error_level;
        this->m_error_description = error_manager.m_error_description;
    }

    //清除所有内容
    void error_manager_clear_all() {
        m_error_code = SUCCESS;
        m_error_level = NORMAL;
        m_error_description.clear();
    }

    //重载=
    Error_manager &operator=(const Error_manager &error_manager) {
        error_manager_reset(error_manager);
        return *this;
    }

    //重载=，支持Error_manager和Error_code的直接转化，会清空错误等级和描述
    Error_manager &operator=(Error_code error_code) {
        error_manager_clear_all();
        set_error_code(error_code);
        return *this;
    }

    //重载==
    bool operator==(const Error_manager &error_manager) {
        return is_equal_error_manager(error_manager);
    }

    //重载==，支持Error_manager和Error_code的直接比较
    bool operator==(Error_code error_code) {
        if (m_error_code == error_code) {
            return true;
        } else {
            return false;
        }
    }

    //重载!=
    bool operator!=(const Error_manager &error_manager) {
        return (!is_equal_error_manager(error_manager));
    }

    //重载!=，支持Error_manager和Error_code的直接比较
    bool operator!=(Error_code error_code) {
        if (m_error_code != error_code) {
            return true;
        } else {
            return false;
        }
    }

    //重载<<，支持cout<<
    friend std::ostream &operator<<(std::ostream &out, Error_manager &error_manager) {
        out << error_manager.to_string();
        return out;
    }


    //获取错误码
    Error_code get_error_code() {
        return m_error_code;
    }

    //获取错误等级
    Error_level get_error_level() {
        return m_error_level;
    }

    //获取错误描述的指针，（浅拷贝）
    std::string get_error_description() {
        return m_error_description;
    }

    //复制错误描述，（深拷贝）
    //output：p_error_description     错误描述的字符串指针，不可以为NULL，必须要有实际的内存
    //output:description_length      错误描述的字符串长度，不可以为0，长度最好足够大，一般256即可。
    void copy_error_description(const char *p_error_description) {
        if (p_error_description != nullptr) {
            m_error_description = std::string(p_error_description);
        }
    }

    //复制错误描述，（深拷贝）
    //output：error_description_string     错误描述的string
    void copy_error_description(std::string error_description_string) {
        m_error_description = error_description_string;
    }

    //设置错误码
    void set_error_code(Error_code error_code) {
        m_error_code = error_code;
    }

    //比较错误等级并升级，取高等级的结果
    void set_error_level_up(Error_level error_level) {
        if (m_error_level < error_level) {
            m_error_level = error_level;
        }
    }

    //比较错误等级并降级，取低等级的结果
    void set_error_level_down(Error_level error_level) {
        if (m_error_level > error_level) {
            m_error_level = error_level;
        }
    }

    //错误等级，设定到固定值
    void set_error_level_location(Error_level error_level) {
        m_error_level = error_level;
    }

    //设置错误描述
    void set_error_description(const char *f, ...) {
        va_list arg_ptr;
        char buf[DESCRIPTION_BUF_SIZE];
        va_start(arg_ptr, f);
        vsnprintf(buf, DESCRIPTION_BUF_SIZE, f, arg_ptr);
        va_end(arg_ptr);
        m_error_description = std::string(buf);
    }

    //设置错误描述
    void set_error_description(std::string error_description_string) {
        m_error_description = error_description_string;
    }

    //尾部追加错误描述
    void add_error_description(const char *f, ...) {
        va_list arg_ptr;
        char buf[DESCRIPTION_BUF_SIZE];
        va_start(arg_ptr, f);
        vsnprintf(buf, DESCRIPTION_BUF_SIZE, f, arg_ptr);
        va_end(arg_ptr);
        m_error_description += std::string(buf);
    }

    //尾部追加错误描述
    void add_error_description(std::string error_description_string) {
        m_error_description += error_description_string;
    }

    //比较错误是否相同，
    // 注：只比较错误码和等级
    bool is_equal_error_manager(const Error_manager &error_manager) {
        if (this->m_error_code == error_manager.m_error_code
            && this->m_error_level == error_manager.m_error_level) {
            return true;
        } else {
            return false;
        }
    }

    //比较并覆盖错误，讲低级错误转为字符串存放于描述中，
    //如果错误相同，则保留this的，将输入参数转入描述。
    void compare_and_cover_error(const Error_manager &error_manager) {
        if (this->m_error_code == SUCCESS) {
            error_manager_reset(error_manager);
        } else if (error_manager.m_error_code == SUCCESS) {
            return;
        } else {
            Error_manager t_error_manager_new;
            std::string pt_string_inside;
            if (this->m_error_level < error_manager.m_error_level) {
                translate_error_to_string(pt_string_inside);
                error_manager_reset(error_manager);
                add_error_description(pt_string_inside);
            } else {
                ((Error_manager &) error_manager).translate_error_to_string(pt_string_inside);
                add_error_description(pt_string_inside);
            }
        }
    }

    //比较并覆盖错误，讲低级错误转为字符串存放于描述中，
    //如果错误相同，则保留this的，将输入参数转入描述。
    void compare_and_cover_error(Error_manager *p_error_manager) {
        if (this->m_error_code == SUCCESS) {
            error_manager_reset(*p_error_manager);
        } else if (p_error_manager->m_error_code == SUCCESS) {
            return;
        } else {
            Error_manager t_error_manager_new;
            std::string pt_string_inside;
            if (this->m_error_level < p_error_manager->m_error_level) {
                translate_error_to_string(pt_string_inside);
                error_manager_reset(*p_error_manager);
                add_error_description(pt_string_inside);
            } else {
                p_error_manager->translate_error_to_string(pt_string_inside);
                add_error_description(pt_string_inside);
            }
        }
    }

    void compare_and_merge_up(const Error_manager &error) {
        if (error.m_error_level > this->m_error_level) {
            this->m_error_level = error.m_error_level;
            this->m_error_code = error.m_error_code;
            this->m_error_description += error.m_error_description;
        }
    }
    void compare_and_merge_down(const Error_manager &error) {
        if (error.m_error_level < this->m_error_level) {
            this->m_error_level = error.m_error_level;
            this->m_error_code = error.m_error_code;
            this->m_error_description += error.m_error_description;
        }
    }


    //output：error_description_string     错误汇总的string
    void translate_error_to_string(std::string error_aggregate_string) {
        char t_string_array[255] = {0};
        sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:",
                m_error_code, m_error_level);

        error_aggregate_string = t_string_array;
        error_aggregate_string += m_error_description;
    }

    //错误码转字符串的简易版，可支持cout<<
    //return     错误汇总的string
    std::string to_string() {
        char t_string_array[255] = {0};
        sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:",
                m_error_code, m_error_level);
        std::string error_aggregate_string = t_string_array;
        error_aggregate_string += m_error_description;
        return error_aggregate_string;
    }


protected:
    Error_code m_error_code;               //错误码
    Error_level m_error_level;              //错误等级
    std::string m_error_description;        // 错误描述

protected://内部功能函数
public:
    //释放错误描述的内存，
    void free_description() {};

    //重新分配错误描述的内存，并从外部拷贝新的（深拷贝）
    //input：p_error_description     错误描述的字符串指针，可以为NULL，
    //input:description_length      错误描述的字符串长度，如果为0，则从p_error_description里面获取有效的长度
    void reallocate_memory_and_copy_string(const char *p_error_description, int description_length = 0) {
    }

    //重新分配错误描述的内存，并从外部拷贝新的（深拷贝）
    //input：error_aggregate_string     错误描述的string
    void reallocate_memory_and_copy_string(std::string error_aggregate_string) {
    }
};