jinchao/XNSim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改了一些报错消息，并使用数据库存储报错信息，以便后续查阅

Browse Source
This commit is contained in:
jinchao 2025-06-06 17:03:35 +08:00
parent 25ca69597b
commit 069ea0ea37
7 changed files with 176 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Release/database/LogInfo.db Normal file
View File

Binary file not shown.

62
Release/include/XNCore/XNDDSInterface.h
View File

@ -75,7 +75,7 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 78");
}
return result;
@ -109,7 +109,7 @@ protected:
setByteArrayFromStdArray(data.value(), thisArray);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 112");
}
}
@ -132,7 +132,7 @@ protected:
getTypeSize<T>());
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 135");
}
}
@ -158,7 +158,7 @@ protected:
setByteArrayFromStdArray(data[i], subArray);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 160");
}
}
}
@ -175,7 +175,7 @@ protected:
if (data) {
return std::to_string(data.value());
} else {
return std::to_string(0);
return "Unknown";
}
} else if constexpr (is_std_array_v<T>) {
if (data) {
@ -186,7 +186,7 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 188");
}
return std::string();
}
@ -218,7 +218,7 @@ protected:
data = temp;
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 220");
}
}
@ -240,7 +240,7 @@ protected:
ss << getStringFromStdArray(data[i]);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 243");
}
}
return ss.str();
@ -272,8 +272,9 @@ protected:
// 对于嵌套数组，递归处理
start_pos = setStdArrayFromString(data[i], value, start_pos + i);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
}
} catch (const std::exception &e) {
throw std::runtime_error("无法解析第 " + std::to_string(i)
@ -289,8 +290,10 @@ protected:
if (data) {
auto temp = data.value();
if constexpr (std::is_arithmetic_v<T1>) {
static_assert(std::is_arithmetic_v<T2>, "模板参数T2必须是算术类型");
static_assert(std::is_convertible_v<T1, T2>, "模板参数T1必须可以转换为T2类型");
static_assert(std::is_arithmetic_v<T2>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
static_assert(std::is_convertible_v<T1, T2>,
"模板参数T1必须可以转换为T2类型，详见XNDDSInterface.cpp：line 295");
model_data = temp;
} else if constexpr (is_std_array_v<T1>) {
size_t arraySize = array_size_v<T1>;
@ -308,18 +311,21 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<sub_array_type>,
"模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
"e.cpp：line 313");
}
} else {
static_assert(std::is_arithmetic_v<array_type>
|| is_std_array_v<array_type>,
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
}
}
} else {
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
}
}
}
@ -328,8 +334,10 @@ protected:
void assign_value_set(eprosima::fastcdr::optional<T1> &data, const T2 &model_data)
{
if constexpr (std::is_arithmetic_v<T1>) {
static_assert(std::is_arithmetic_v<T2>, "模板参数T2必须是算术类型");
static_assert(std::is_convertible_v<T2, T1>, "模板参数T2必须可以转换为T1类型");
static_assert(std::is_arithmetic_v<T2>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
static_assert(std::is_convertible_v<T2, T1>,
"模板参数T2必须可以转换为T1类型，详见XNDDSInterface.cpp：line 339");
data = model_data;
} else if constexpr (is_std_array_v<T1>) {
T1 temp;
@ -347,18 +355,22 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<sub_array_type>,
"模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
"cpp：line 357");
}
} else {
static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
}
}
data = temp;
} else {
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
}
}

65
Release/include/XNCore/XNLogger.h
View File

@ -178,46 +178,59 @@ public:
}
private:
// 辅助函数，用于格式化消息
/**
* @brief 将参数转换为字符串
* @tparam T 参数类型
* @param arg 要转换的参数
* @return 转换后的字符串
*/
template <typename T>
static std::string convertToString(const T &arg)
{
if constexpr (std::is_arithmetic<T>::value) {
if constexpr (std::is_arithmetic_v<T>) {
return std::to_string(arg); // 处理数值类型
} else {
} else if constexpr (std::is_same_v<T, std::string>) {
return arg;
} else if constexpr (std::is_convertible_v<T, std::string>) {
return std::string(arg);
} else if constexpr (std::is_same_v<T, char *> || std::is_same_v<T, const char *>) {
return std::string(arg);
} else {
static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string>
|| std::is_convertible_v<T, std::string> || std::is_same_v<T, char *>
|| std::is_same_v<T, const char *>,
"错误码：010211001，不支持的类型转换，详见XNLogger.cpp：line 199");
}
}
// 递归变参函数，用于处理多个参数
template <typename T, typename... Args>
static std::string formatMessage(const std::string &message, T arg, Args... args)
/**
* @brief 格式化日志消息，顺序替换%1、%2、%3……
* @tparam Args 参数类型
* @param message 日志消息
* @param args 参数包
* @return 格式化后的消息
*/
template <typename... Args>
static std::string formatMessage(const std::string &message, Args &&...args)
{
// 查找下一个参数占位符
std::string result = message;
size_t paramIndex = 0;
size_t pos = 0;
static_assert(sizeof...(Args) <= 9,
"错误码：010211002，单条日志参数数量超过限制，详见XNLogger.cpp：line 216");
// 找到当前参数对应的占位符
while (true) {
std::string placeholder = "%" + std::to_string(paramIndex + 1);
pos = result.find(placeholder);
std::string result = message;
// 使用初始化列表展开参数包
int index = 1;
// 使用lambda和std::initializer_list展开参数包
(void)std::initializer_list<int>{(
[&result, &index](const auto &value) {
std::string placeholder = "%" + std::to_string(index++);
size_t pos = result.find(placeholder);
if (pos != std::string::npos) {
// 替换占位符，使用placeholder的长度
result.replace(pos, placeholder.length(), convertToString(arg));
break;
result.replace(pos, placeholder.length(), convertToString(value));
}
paramIndex++;
if (paramIndex > 100) { // 防止无限循环
}(args),
0)...};
return result;
}
}
return formatMessage(result, args...);
}
// 基础情况
static std::string formatMessage(const std::string &message) { return message; }
};
/**

60
XNCore/XNDDSInterface.h
View File

@ -75,7 +75,7 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 78");
}
return result;
@ -109,7 +109,7 @@ protected:
setByteArrayFromStdArray(data.value(), thisArray);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 112");
}
}
@ -132,7 +132,7 @@ protected:
getTypeSize<T>());
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 135");
}
}
@ -158,7 +158,7 @@ protected:
setByteArrayFromStdArray(data[i], subArray);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 160");
}
}
}
@ -186,7 +186,7 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 188");
}
return std::string();
}
@ -218,7 +218,7 @@ protected:
data = temp;
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 220");
}
}
@ -240,7 +240,7 @@ protected:
ss << getStringFromStdArray(data[i]);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 243");
}
}
return ss.str();
@ -272,8 +272,9 @@ protected:
// 对于嵌套数组，递归处理
start_pos = setStdArrayFromString(data[i], value, start_pos + i);
} else {
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
}
} catch (const std::exception &e) {
throw std::runtime_error("无法解析第 " + std::to_string(i)
@ -289,8 +290,10 @@ protected:
if (data) {
auto temp = data.value();
if constexpr (std::is_arithmetic_v<T1>) {
static_assert(std::is_arithmetic_v<T2>, "模板参数T2必须是算术类型");
static_assert(std::is_convertible_v<T1, T2>, "模板参数T1必须可以转换为T2类型");
static_assert(std::is_arithmetic_v<T2>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
static_assert(std::is_convertible_v<T1, T2>,
"模板参数T1必须可以转换为T2类型，详见XNDDSInterface.cpp：line 295");
model_data = temp;
} else if constexpr (is_std_array_v<T1>) {
size_t arraySize = array_size_v<T1>;
@ -308,18 +311,21 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<sub_array_type>,
"模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
"e.cpp：line 313");
}
} else {
static_assert(std::is_arithmetic_v<array_type>
|| is_std_array_v<array_type>,
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
}
}
} else {
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
}
}
}
@ -328,8 +334,10 @@ protected:
void assign_value_set(eprosima::fastcdr::optional<T1> &data, const T2 &model_data)
{
if constexpr (std::is_arithmetic_v<T1>) {
static_assert(std::is_arithmetic_v<T2>, "模板参数T2必须是算术类型");
static_assert(std::is_convertible_v<T2, T1>, "模板参数T2必须可以转换为T1类型");
static_assert(std::is_arithmetic_v<T2>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
static_assert(std::is_convertible_v<T2, T1>,
"模板参数T2必须可以转换为T1类型，详见XNDDSInterface.cpp：line 339");
data = model_data;
} else if constexpr (is_std_array_v<T1>) {
T1 temp;
@ -347,18 +355,22 @@ protected:
}
} else {
static_assert(std::is_arithmetic_v<sub_array_type>,
"模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
"cpp：line 357");
}
} else {
static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
}
}
data = temp;
} else {
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型");
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
}
}

6
XNCore/XNDDSManager.cpp
View File

@ -20,7 +20,7 @@ bool XNDDSManager::Initialize()
d->_status = XNFrameObjectStatus::Initialized;
d->participant_ = nullptr;
d->topics_.clear();
LOG_INFO("XNDDSManager Initialize Success!");
LOG_INFO("DDS管理器初始化成功!");
return true;
}
@ -28,7 +28,7 @@ bool XNDDSManager::PrepareForExecute()
{
T_D();
d->_status = XNFrameObjectStatus::Ready;
LOG_INFO("XNDDSManager is prepared!");
LOG_INFO("DDS管理器准备就绪!");
return true;
}
@ -40,6 +40,6 @@ void XNDDSManager::SetDomainID(uint32_t domainID)
d->participant_ = FAST_DDS_MACRO::DomainParticipantFactory::get_instance()->create_participant(
domainID, participantQos);
if (d->participant_ == nullptr) {
LOG_ERROR("0x2130 Create DomainParticipant Failed!");
LOG_ERROR("0x2130 DDS管理器创建域参与者失败!");
}
}

24
XNCore/XNFramework.cpp
View File

@ -82,7 +82,7 @@ void XNFramework::SetCpuAffinity(uint32_t cpuAffinity)
bool XNFramework::Initialize(uint32_t initialType)
{
T_D();
LOG_INFO("XNFramework Initialize ...");
LOG_INFO("D01054001：主框架正在初始化...");
d->ddsManager->SetFramework(XN_THISPTR);
d->timeManager->SetFramework(XN_THISPTR);
d->threadManager->SetFramework(XN_THISPTR);
@ -92,47 +92,47 @@ bool XNFramework::Initialize(uint32_t initialType)
d->eventManager->SetFramework(XN_THISPTR);
bool ret = d->eventManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052001：主框架初始化失败！");
return false;
}
ret = d->timeManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052002：主框架初始化失败！");
return false;
}
ret = d->ddsManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052003：主框架初始化失败！");
return false;
}
ret = d->serviceManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052004：主框架初始化失败！");
return false;
}
ret = d->threadManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052005：主框架初始化失败！");
return false;
}
ret = d->modelManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052006：主框架初始化失败！");
return false;
}
ret = d->scenarioManager->Initialize();
if (!ret) {
LOG_ERROR("XNFramework Initialize Failed!");
LOG_ERROR("B01052007：主框架初始化失败！");
return false;
}
LOG_INFO("XNFramework Initialize Success!");
LOG_INFO("XNFramework Analyze Scenario Xml ...");
LOG_INFO("D01054002：主框架初始化成功！");
LOG_INFO("D01054003：开始解析构型文件 ...");
ret = d->scenarioManager->AnalysisScenarioXml(d->scenarioXml, initialType);
if (!ret) {
LOG_ERROR("XNFramework Analyze Scenario Xml Failed!");
LOG_ERROR("B01052008：主框架解析构型文件失败！");
return false;
}
LOG_INFO("XNFramework Analyze Scenario Xml Success!");
LOG_INFO("D01054004：解析构型文件成功！");
return true;
}

65
XNCore/XNLogger.h
View File

@ -178,46 +178,59 @@ public:
}
private:
// 辅助函数，用于格式化消息
/**
* @brief 将参数转换为字符串
* @tparam T 参数类型
* @param arg 要转换的参数
* @return 转换后的字符串
*/
template <typename T>
static std::string convertToString(const T &arg)
{
if constexpr (std::is_arithmetic<T>::value) {
if constexpr (std::is_arithmetic_v<T>) {
return std::to_string(arg); // 处理数值类型
} else {
} else if constexpr (std::is_same_v<T, std::string>) {
return arg;
} else if constexpr (std::is_convertible_v<T, std::string>) {
return std::string(arg);
} else if constexpr (std::is_same_v<T, char *> || std::is_same_v<T, const char *>) {
return std::string(arg);
} else {
static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string>
|| std::is_convertible_v<T, std::string> || std::is_same_v<T, char *>
|| std::is_same_v<T, const char *>,
"A01021001: 不支持的类型转换，详见XNLogger.cpp：line 199");
}
}
// 递归变参函数，用于处理多个参数
template <typename T, typename... Args>
static std::string formatMessage(const std::string &message, T arg, Args... args)
/**
* @brief 格式化日志消息，顺序替换%1、%2、%3……
* @tparam Args 参数类型
* @param message 日志消息
* @param args 参数包
* @return 格式化后的消息
*/
template <typename... Args>
static std::string formatMessage(const std::string &message, Args &&...args)
{
// 查找下一个参数占位符
std::string result = message;
size_t paramIndex = 0;
size_t pos = 0;
static_assert(sizeof...(Args) <= 9,
"A01021002: 单条日志参数数量超过限制，详见XNLogger.cpp：line 216");
// 找到当前参数对应的占位符
while (true) {
std::string placeholder = "%" + std::to_string(paramIndex + 1);
pos = result.find(placeholder);
std::string result = message;
// 使用初始化列表展开参数包
int index = 1;
// 使用lambda和std::initializer_list展开参数包
(void)std::initializer_list<int>{(
[&result, &index](const auto &value) {
std::string placeholder = "%" + std::to_string(index++);
size_t pos = result.find(placeholder);
if (pos != std::string::npos) {
// 替换占位符，使用placeholder的长度
result.replace(pos, placeholder.length(), convertToString(arg));
break;
result.replace(pos, placeholder.length(), convertToString(value));
}
paramIndex++;
if (paramIndex > 100) { // 防止无限循环
}(args),
0)...};
return result;
}
}
return formatMessage(result, args...);
}
// 基础情况
static std::string formatMessage(const std::string &message) { return message; }
};
/**