mirror of
https://github.com/MaaAssistantArknights/MaaAssistantArknights.git
synced 2026-07-16 17:57:01 +08:00
1153 lines
46 KiB
C++
1153 lines
46 KiB
C++
#include "TaskData.h"
|
||
|
||
#include <algorithm>
|
||
#include <meojson/json.hpp>
|
||
|
||
#ifdef ASST_DEBUG
|
||
#include <queue>
|
||
#endif
|
||
|
||
#include "Common/AsstTypes.h"
|
||
#include "GeneralConfig.h"
|
||
#include "TemplResource.h"
|
||
#include "Utils/Logger.hpp"
|
||
#include "Utils/Ranges.hpp"
|
||
#include "Utils/StringMisc.hpp"
|
||
|
||
namespace asst
|
||
{
|
||
// base types
|
||
template <typename OutT>
|
||
requires(std::constructible_from<json::value, OutT>)
|
||
bool parse_json_as(const json::value& input, OutT& output)
|
||
{
|
||
if (input.is<OutT>()) {
|
||
output = input.as<OutT>();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool parse_json_as(const json::value& input, AlgorithmType& output)
|
||
{
|
||
if (input.is_string()) {
|
||
output = get_algorithm_type(input.as_string());
|
||
return output != AlgorithmType::Invalid;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool parse_json_as(const json::value& input, ProcessTaskAction& output)
|
||
{
|
||
if (input.is_string()) {
|
||
output = get_action_type(input.as_string());
|
||
return output != ProcessTaskAction::Invalid;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// std::pair<FirstT, SecondT> <- [first, second]
|
||
template <typename FirstT, typename SecondT>
|
||
requires(requires(const json::value& input, FirstT x, SecondT y) {
|
||
parse_json_as(input, x) && parse_json_as(input, y);
|
||
})
|
||
bool parse_json_as(const json::value& input, std::pair<FirstT, SecondT>& output)
|
||
{
|
||
if (!input.is_array()) {
|
||
return false;
|
||
}
|
||
const auto& items = input.as_array();
|
||
if (items.size() != 2) {
|
||
return false;
|
||
}
|
||
return parse_json_as(items[0], output.first) && parse_json_as(items[1], output.second);
|
||
}
|
||
|
||
// std::vector<ValT> <- val | [val, ...]
|
||
template <typename ValT>
|
||
requires(requires(const json::value& input, ValT x) { parse_json_as(input, x); })
|
||
bool parse_json_as(const json::value& input, std::vector<ValT>& output)
|
||
{
|
||
if (!input.is_array()) {
|
||
if constexpr (std::constructible_from<json::value, ValT>) {
|
||
if (input.is<ValT>()) {
|
||
output = { input.as<ValT>() };
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
const auto& items = input.as_array();
|
||
output.clear();
|
||
for (const auto& item : items) {
|
||
ValT val;
|
||
if (!parse_json_as(item, val)) {
|
||
output.clear();
|
||
return false;
|
||
}
|
||
output.emplace_back(std::move(val));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// asst::Rect <- [int, int, int, int]
|
||
bool parse_json_as(const json::value& input, asst::Rect& output)
|
||
{
|
||
if (!input.is_array()) {
|
||
return false;
|
||
}
|
||
const auto& items = input.as_array();
|
||
if (items.size() != 4) {
|
||
return false;
|
||
}
|
||
return parse_json_as(items[0], output.x) && parse_json_as(items[1], output.y) &&
|
||
parse_json_as(items[2], output.width) && parse_json_as(items[3], output.height);
|
||
}
|
||
|
||
template <typename OutT>
|
||
std::optional<OutT> parse_json_as(const json::value& input)
|
||
{
|
||
OutT output;
|
||
return parse_json_as(input, output) ? output : std::nullopt;
|
||
}
|
||
|
||
template <typename OutT, typename DefaultT>
|
||
requires(std::constructible_from<OutT, DefaultT> || std::constructible_from<OutT, std::invoke_result_t<DefaultT>>)
|
||
bool get_value_or(std::string_view repr, const json::value& input, const std::string& key, OutT& output,
|
||
DefaultT&& default_val)
|
||
{
|
||
auto opt = input.find(key);
|
||
if (!opt) {
|
||
if constexpr (std::constructible_from<OutT, DefaultT>) {
|
||
output = std::forward<DefaultT>(default_val);
|
||
}
|
||
else {
|
||
output = default_val();
|
||
}
|
||
return true;
|
||
}
|
||
if (parse_json_as(*opt, output)) {
|
||
#ifdef ASST_DEBUG
|
||
// 如果有默认值，检查是否与默认值相同
|
||
if constexpr (std::constructible_from<OutT, DefaultT>) {
|
||
if (output == default_val) {
|
||
Log.warn("Value of", key, "in", repr, "is same as default value");
|
||
}
|
||
}
|
||
else {
|
||
if (output == default_val()) {
|
||
Log.warn("Value of", key, "in", repr, "is same as default value");
|
||
}
|
||
}
|
||
#endif
|
||
return true;
|
||
}
|
||
Log.error("Invalid type of", key, "in", repr);
|
||
return false;
|
||
}
|
||
} // namespace asst
|
||
|
||
const std::unordered_set<std::string>& asst::TaskData::get_templ_required() const noexcept
|
||
{
|
||
return m_templ_required;
|
||
}
|
||
asst::TaskData::taskptr_t asst::TaskData::get_raw(std::string_view name)
|
||
{
|
||
if (!generate_task_and_its_base(name, true)) [[unlikely]] {
|
||
return nullptr;
|
||
}
|
||
|
||
if (auto it = m_raw_all_tasks_info.find(name); it != m_raw_all_tasks_info.cend()) {
|
||
return it->second;
|
||
}
|
||
|
||
// `@` 前面的字符长度
|
||
size_t name_len = name.find('@');
|
||
if (name_len == std::string_view::npos) [[unlikely]] {
|
||
return nullptr;
|
||
}
|
||
|
||
// 隐式 TemplateTask
|
||
if (auto base_task_iter = get_raw(name.substr(name_len + 1))) {
|
||
return _generate_task_info(base_task_iter, name.substr(0, name_len));
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::get(std::string_view name)
|
||
{
|
||
// 普通任务 或 已经生成过的高级任务
|
||
if (auto it = m_all_tasks_info.find(name); it != m_all_tasks_info.cend()) [[likely]] {
|
||
return it->second;
|
||
}
|
||
|
||
auto raw_task = get_raw(name);
|
||
auto task = _generate_task_info(raw_task);
|
||
if (!task) [[unlikely]] {
|
||
return nullptr;
|
||
}
|
||
bool changed = false; // 任务列表是否发生变化（是否包含虚任务）
|
||
#define ASST_TASKDATA_GET_IF_BRANCH(list, m) \
|
||
task->list.clear(); \
|
||
if (!compile_tasklist(task->list, raw_task->list, name, changed, m)) [[unlikely]] { \
|
||
Log.error("Generate task_list", std::string(name) + "->" #list, "failed."); \
|
||
return nullptr; \
|
||
}
|
||
// 展开五个任务列表中的虚任务
|
||
ASST_TASKDATA_GET_IF_BRANCH(next, false);
|
||
ASST_TASKDATA_GET_IF_BRANCH(sub, true);
|
||
ASST_TASKDATA_GET_IF_BRANCH(exceeded_next, false);
|
||
ASST_TASKDATA_GET_IF_BRANCH(on_error_next, false);
|
||
ASST_TASKDATA_GET_IF_BRANCH(reduce_other_times, true);
|
||
#undef ASST_TASKDATA_GET_IF_BRANCH
|
||
|
||
constexpr size_t MAX_TASKS_SIZE = 65535;
|
||
if (m_all_tasks_info.size() < MAX_TASKS_SIZE) [[likely]] {
|
||
// 保存最终生成的任务，下次查询时可以直接返回
|
||
return insert_or_assign_task(name, changed ? task : raw_task).first->second;
|
||
}
|
||
else {
|
||
// 个数超过上限时不保存，直接返回，防止内存占用过大
|
||
Log.warn("Task count has exceeded the upper limit:", MAX_TASKS_SIZE, "current task:", name);
|
||
return changed ? task : raw_task;
|
||
}
|
||
}
|
||
|
||
bool asst::TaskData::lazy_parse(const json::value& json)
|
||
{
|
||
LogTraceFunction;
|
||
|
||
if (!json.is_object()) {
|
||
Log.error("parameter json is not a json::object");
|
||
return false;
|
||
}
|
||
|
||
for (const auto& [name, task_json] : json.as_object()) {
|
||
std::string_view name_view = task_name_view(name);
|
||
if (task_json.get("baseTask", "") == "#none") {
|
||
// 不继承同名任务参数
|
||
m_json_all_tasks_info[name_view] = task_json.as_object();
|
||
m_json_all_tasks_info[name_view].erase("baseTask");
|
||
continue;
|
||
}
|
||
if (m_json_all_tasks_info.find(name_view) == m_json_all_tasks_info.cend()) {
|
||
m_json_all_tasks_info.emplace(name_view, task_json.as_object());
|
||
continue;
|
||
}
|
||
for (const auto& [key, value] : task_json.as_object()) {
|
||
m_json_all_tasks_info[name_view][key] = value;
|
||
}
|
||
}
|
||
|
||
clear_tasks();
|
||
|
||
#ifdef ASST_DEBUG
|
||
{
|
||
bool validity = true;
|
||
std::queue<std::string_view> task_queue;
|
||
std::unordered_set<std::string_view> checking_task_set;
|
||
|
||
for (std::string_view name : m_json_all_tasks_info | views::keys) {
|
||
m_task_status[name] = ToBeGenerate;
|
||
task_queue.push(name);
|
||
checking_task_set.insert(name);
|
||
}
|
||
|
||
for (const auto& [name, task_json] : m_json_all_tasks_info) [[likely]] {
|
||
validity &= syntax_check(name, task_json);
|
||
}
|
||
|
||
const size_t MAX_CHECKING_SIZE = 10000;
|
||
while (!task_queue.empty() && checking_task_set.size() <= MAX_CHECKING_SIZE) {
|
||
std::string_view name = task_queue.front();
|
||
task_queue.pop();
|
||
auto task = get(name);
|
||
if (task == nullptr) [[unlikely]] {
|
||
Log.error("Task", name, "not successfully generated");
|
||
validity = false;
|
||
continue;
|
||
}
|
||
auto check_tasklist = [&](const tasklist_t& task_list, std::string_view list_type,
|
||
bool enable_justreturn_check = false) {
|
||
std::unordered_set<std::string_view> tasks_set {};
|
||
std::string justreturn_task_name = "";
|
||
for (const std::string& task_name : task_list) {
|
||
if (tasks_set.contains(task_name)) [[unlikely]] {
|
||
continue;
|
||
}
|
||
// 检查是否有 JustReturn 任务不是最后一个任务
|
||
if (enable_justreturn_check && !justreturn_task_name.empty()) [[unlikely]] {
|
||
Log.error((std::string(name) += "->") += list_type,
|
||
"has a not-final JustReturn task:", justreturn_task_name);
|
||
justreturn_task_name = "";
|
||
validity = false;
|
||
}
|
||
|
||
if (auto ptr = get_raw(task_name); ptr == nullptr) [[unlikely]] {
|
||
Log.error(task_name, "in", (std::string(name) += "->") += list_type, "is null");
|
||
validity = false;
|
||
continue;
|
||
}
|
||
else if (ptr->algorithm == AlgorithmType::JustReturn) {
|
||
justreturn_task_name = ptr->name;
|
||
}
|
||
|
||
if (!checking_task_set.contains(task_name)) {
|
||
task_queue.emplace(task_name_view(task_name));
|
||
checking_task_set.emplace(task_name_view(task_name));
|
||
}
|
||
tasks_set.emplace(task_name_view(task_name));
|
||
}
|
||
|
||
return true;
|
||
};
|
||
bool enable_justreturn_check = true;
|
||
if (name.ends_with("LoadingText") || name.ends_with("LoadingIcon")) {
|
||
// 放宽对 Loading 类任务的限制，不然 JustReturn 的任务如果本身有 JR 的 next，就不能 @Loading 了
|
||
enable_justreturn_check = false;
|
||
}
|
||
check_tasklist(task->next, "next", enable_justreturn_check);
|
||
check_tasklist(task->sub, "sub");
|
||
check_tasklist(task->exceeded_next, "exceeded_next", enable_justreturn_check);
|
||
check_tasklist(task->on_error_next, "on_error_next", enable_justreturn_check);
|
||
check_tasklist(task->reduce_other_times, "reduce_other_times");
|
||
}
|
||
if (checking_task_set.size() > MAX_CHECKING_SIZE) {
|
||
// 生成超出上限一般是出现了会导致无限隐式生成的任务。比如 "#self@LoadingText". 这里给个警告.
|
||
Log.warn("Generating exceeded limit when syntax_check.");
|
||
}
|
||
else {
|
||
Log.trace(checking_task_set.size(), "tasks checked.");
|
||
}
|
||
clear_tasks();
|
||
if (!validity) return false;
|
||
}
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
bool asst::TaskData::parse(const json::value& json)
|
||
{
|
||
LogTraceFunction;
|
||
|
||
if (!lazy_parse(json)) return false;
|
||
|
||
// 本来重构之后完全支持惰性加载，但是发现模板图片不支持（
|
||
for (std::string_view name : m_json_all_tasks_info | views::keys) {
|
||
generate_task_and_its_base(name, true);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void asst::TaskData::clear_tasks()
|
||
{
|
||
// 注意：这会导致已经通过 get 获取的任务指针内容不会更新
|
||
// 即运行期修改对已经获取的任务指针无效，但是不会导致崩溃；要想更新，需要重新获取任务指针
|
||
m_all_tasks_info.clear();
|
||
m_raw_all_tasks_info.clear();
|
||
for (std::string_view name : m_json_all_tasks_info | views::keys) {
|
||
m_task_status[task_name_view(name)] = ToBeGenerate;
|
||
}
|
||
}
|
||
|
||
void asst::TaskData::set_task_base(const std::string_view task_name, std::string base_task_name)
|
||
{
|
||
m_json_all_tasks_info[task_name_view(task_name)]["baseTask"] = std::move(base_task_name);
|
||
clear_tasks();
|
||
}
|
||
|
||
bool asst::TaskData::generate_task_and_its_base(std::string_view name, bool must_true)
|
||
{
|
||
auto generate_task = [&](std::string_view name, std::string_view prefix, taskptr_t base_ptr,
|
||
const json::value& task_json) {
|
||
auto task_info_ptr = generate_task_info(name, task_json, base_ptr, prefix);
|
||
if (task_info_ptr == nullptr) {
|
||
return false;
|
||
}
|
||
m_task_status[task_name_view(name)] = NotToBeGenerate;
|
||
// 保存虚任务未展开的任务
|
||
insert_or_assign_raw_task(name, task_info_ptr);
|
||
return true;
|
||
};
|
||
switch (m_task_status[task_name_view(name)]) {
|
||
case NotToBeGenerate:
|
||
// 已经显式生成
|
||
if (m_raw_all_tasks_info.contains(name)) {
|
||
return true;
|
||
}
|
||
|
||
// 隐式生成的资源
|
||
if (size_t p = name.find('@'); p != std::string::npos) {
|
||
return generate_task_and_its_base(name.substr(p + 1), must_true);
|
||
}
|
||
|
||
m_task_status[name] = NotExists;
|
||
[[fallthrough]];
|
||
case NotExists:
|
||
if (must_true) {
|
||
// 必须有名字为 name 的资源
|
||
Log.error("Unknown task:", name);
|
||
}
|
||
// 不一定必须有名字为 name 的资源，例如 Roguelike@Abandon 不必有 Abandon.
|
||
return false;
|
||
case ToBeGenerate: {
|
||
if (!m_json_all_tasks_info.contains(name)) [[unlikely]] {
|
||
// 这段正常情况来说是不可能的，除非有 string_view 引用失效
|
||
Log.error("Unexcepted ToBeGenerate task:", name);
|
||
return false;
|
||
}
|
||
|
||
m_task_status[name] = Generating;
|
||
|
||
const json::value& task_json = m_json_all_tasks_info.at(name);
|
||
|
||
// BaseTask
|
||
if (auto opt = task_json.find<std::string>("baseTask")) {
|
||
std::string base = opt.value();
|
||
return generate_task_and_its_base(base, must_true) && generate_task(name, "", get_raw(base), task_json);
|
||
}
|
||
|
||
// TemplateTask
|
||
if (size_t p = name.find('@'); p != std::string::npos) {
|
||
if (std::string_view base = name.substr(p + 1); generate_task_and_its_base(base, false)) {
|
||
#ifdef ASST_DEBUG
|
||
if (task_json.as_object().empty() && get_raw(base)->algorithm != AlgorithmType::MatchTemplate) {
|
||
// 多余的空任务
|
||
Log.warn("Task", name, "is a redundant empty task because it is not MatchTemplate");
|
||
}
|
||
#endif
|
||
return generate_task(name, name.substr(0, p), get_raw(base), task_json);
|
||
}
|
||
}
|
||
return generate_task(name, "", nullptr, task_json);
|
||
}
|
||
[[unlikely]] case Generating:
|
||
Log.error("Task", name, "is generated cyclically");
|
||
return false;
|
||
[[unlikely]] default:
|
||
Log.error("Task", name, "has unknown status");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::generate_task_info(std::string_view name, const json::value& task_json,
|
||
taskptr_t default_ptr, std::string_view task_prefix)
|
||
{
|
||
if (default_ptr == nullptr) {
|
||
default_ptr = default_task_info_ptr;
|
||
task_prefix = "";
|
||
}
|
||
|
||
// 获取 algorithm 并按照 algorithm 生成 TaskInfo
|
||
AlgorithmType algorithm;
|
||
get_value_or(name, task_json, "algorithm", algorithm, default_ptr->algorithm);
|
||
|
||
taskptr_t task_ptr = nullptr;
|
||
switch (algorithm) {
|
||
case AlgorithmType::MatchTemplate:
|
||
task_ptr = generate_match_task_info(name, task_json, std::dynamic_pointer_cast<MatchTaskInfo>(default_ptr));
|
||
break;
|
||
case AlgorithmType::OcrDetect:
|
||
task_ptr = generate_ocr_task_info(name, task_json, std::dynamic_pointer_cast<OcrTaskInfo>(default_ptr));
|
||
break;
|
||
case AlgorithmType::Hash:
|
||
task_ptr = generate_hash_task_info(name, task_json, std::dynamic_pointer_cast<HashTaskInfo>(default_ptr));
|
||
break;
|
||
case AlgorithmType::JustReturn:
|
||
task_ptr = std::make_shared<TaskInfo>();
|
||
break;
|
||
default:
|
||
Log.error("Unknown algorithm in task", name);
|
||
return nullptr;
|
||
}
|
||
|
||
if (task_ptr == nullptr) {
|
||
return nullptr;
|
||
}
|
||
|
||
// 不管什么algorithm，都有基础成员（next, roi, 等等）
|
||
if (!append_base_task_info(task_ptr, name, task_json, default_ptr, task_prefix)) {
|
||
return nullptr;
|
||
}
|
||
task_ptr->algorithm = algorithm;
|
||
task_ptr->name = name;
|
||
return task_ptr;
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::generate_match_task_info(std::string_view name, const json::value& task_json,
|
||
std::shared_ptr<MatchTaskInfo> default_ptr)
|
||
{
|
||
if (default_ptr == nullptr) {
|
||
default_ptr = default_match_task_info_ptr;
|
||
}
|
||
auto match_task_info_ptr = std::make_shared<MatchTaskInfo>();
|
||
if (!get_value_or(name, task_json, "template", match_task_info_ptr->templ_names,
|
||
[&]() { return std::vector { std::string(name) + ".png" }; })) {
|
||
return nullptr;
|
||
}
|
||
|
||
m_templ_required.insert(match_task_info_ptr->templ_names.begin(), match_task_info_ptr->templ_names.end());
|
||
|
||
// 其余若留空则继承模板任务
|
||
|
||
auto threshold_opt = task_json.find("templThreshold");
|
||
if (!threshold_opt) {
|
||
match_task_info_ptr->templ_thresholds = default_ptr->templ_thresholds;
|
||
match_task_info_ptr->templ_thresholds.resize(match_task_info_ptr->templ_names.size(),
|
||
default_ptr->templ_thresholds.back());
|
||
}
|
||
else if (threshold_opt->is_number()) {
|
||
// 单个数值时，所有模板都使用这个阈值
|
||
match_task_info_ptr->templ_thresholds.resize(match_task_info_ptr->templ_names.size(),
|
||
threshold_opt->as_double());
|
||
}
|
||
else if (threshold_opt->is_array()) {
|
||
ranges::copy(threshold_opt->as_array() | views::transform(&ranges::range_value_t<json::array>::as_double),
|
||
std::back_inserter(match_task_info_ptr->templ_thresholds));
|
||
}
|
||
else {
|
||
Log.error("Invalid templThreshold type in task", name);
|
||
return nullptr;
|
||
}
|
||
|
||
if (match_task_info_ptr->templ_names.size() != match_task_info_ptr->templ_thresholds.size()) {
|
||
Log.error("Template count and templThreshold count not match in task", name);
|
||
return nullptr;
|
||
}
|
||
|
||
if (match_task_info_ptr->templ_names.size() == 0 || match_task_info_ptr->templ_thresholds.size() == 0) {
|
||
Log.error("Template or templThreshold is empty in task", name);
|
||
return nullptr;
|
||
}
|
||
|
||
get_value_or(name, task_json, "maskRange", match_task_info_ptr->mask_range, default_ptr->mask_range);
|
||
return match_task_info_ptr;
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::generate_ocr_task_info(std::string_view name, const json::value& task_json,
|
||
std::shared_ptr<OcrTaskInfo> default_ptr)
|
||
{
|
||
if (default_ptr == nullptr) {
|
||
default_ptr = default_ocr_task_info_ptr;
|
||
}
|
||
auto ocr_task_info_ptr = std::make_shared<OcrTaskInfo>();
|
||
|
||
// text 不允许为字符串，必须是字符串数组，不能用 get_value_or
|
||
auto array_opt = task_json.find<json::array>("text");
|
||
ocr_task_info_ptr->text = array_opt ? to_string_list(array_opt.value()) : default_ptr->text;
|
||
#ifdef ASST_DEBUG
|
||
if (!array_opt && default_ptr->text.empty()) {
|
||
Log.warn("Ocr task", name, "has implicit empty text.");
|
||
}
|
||
#endif
|
||
get_value_or(name, task_json, "fullMatch", ocr_task_info_ptr->full_match, default_ptr->full_match);
|
||
get_value_or(name, task_json, "isAscii", ocr_task_info_ptr->is_ascii, default_ptr->is_ascii);
|
||
get_value_or(name, task_json, "withoutDet", ocr_task_info_ptr->without_det, default_ptr->without_det);
|
||
get_value_or(name, task_json, "replaceFull", ocr_task_info_ptr->replace_full, default_ptr->replace_full);
|
||
get_value_or(name, task_json, "ocrReplace", ocr_task_info_ptr->replace_map, default_ptr->replace_map);
|
||
return ocr_task_info_ptr;
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::generate_hash_task_info(std::string_view name, const json::value& task_json,
|
||
std::shared_ptr<HashTaskInfo> default_ptr)
|
||
{
|
||
if (default_ptr == nullptr) {
|
||
default_ptr = default_hash_task_info_ptr;
|
||
}
|
||
auto hash_task_info_ptr = std::make_shared<HashTaskInfo>();
|
||
// hash 不允许为字符串，必须是字符串数组，不能用 get_value_or
|
||
auto array_opt = task_json.find<json::array>("hash");
|
||
hash_task_info_ptr->hashes = array_opt ? to_string_list(array_opt.value()) : default_ptr->hashes;
|
||
#ifdef ASST_DEBUG
|
||
if (!array_opt && default_ptr->hashes.empty()) {
|
||
Log.warn("Hash task", name, "has implicit empty hashes.");
|
||
}
|
||
#endif
|
||
get_value_or(name, task_json, "threshold", hash_task_info_ptr->dist_threshold, default_ptr->dist_threshold);
|
||
get_value_or(name, task_json, "maskRange", hash_task_info_ptr->mask_range, default_ptr->mask_range);
|
||
get_value_or(name, task_json, "bound", hash_task_info_ptr->bound, default_ptr->bound);
|
||
return hash_task_info_ptr;
|
||
}
|
||
|
||
bool asst::TaskData::append_base_task_info(taskptr_t task_info_ptr, std::string_view name, const json::value& task_json,
|
||
taskptr_t default_ptr, std::string_view task_prefix)
|
||
{
|
||
if (default_ptr == nullptr) {
|
||
default_ptr = default_task_info_ptr;
|
||
}
|
||
|
||
get_value_or(name, task_json, "action", task_info_ptr->action, default_ptr->action);
|
||
get_value_or(name, task_json, "cache", task_info_ptr->cache, default_ptr->cache);
|
||
get_value_or(name, task_json, "maxTimes", task_info_ptr->max_times, default_ptr->max_times);
|
||
get_value_or(name, task_json, "exceededNext", task_info_ptr->exceeded_next,
|
||
[&]() { return append_prefix(default_ptr->exceeded_next, task_prefix); });
|
||
get_value_or(name, task_json, "onErrorNext", task_info_ptr->on_error_next,
|
||
[&]() { return append_prefix(default_ptr->on_error_next, task_prefix); });
|
||
get_value_or(name, task_json, "preDelay", task_info_ptr->pre_delay, default_ptr->pre_delay);
|
||
get_value_or(name, task_json, "postDelay", task_info_ptr->post_delay, default_ptr->post_delay);
|
||
get_value_or(name, task_json, "reduceOtherTimes", task_info_ptr->reduce_other_times,
|
||
[&]() { return append_prefix(default_ptr->reduce_other_times, task_prefix); });
|
||
get_value_or(name, task_json, "roi", task_info_ptr->roi, default_ptr->roi);
|
||
get_value_or(name, task_json, "sub", task_info_ptr->sub,
|
||
[&]() { return append_prefix(default_ptr->sub, task_prefix); });
|
||
get_value_or(name, task_json, "subErrorIgnored", task_info_ptr->sub_error_ignored, default_ptr->sub_error_ignored);
|
||
get_value_or(name, task_json, "next", task_info_ptr->next,
|
||
[&]() { return append_prefix(default_ptr->next, task_prefix); });
|
||
get_value_or(name, task_json, "rectMove", task_info_ptr->rect_move, default_ptr->rect_move);
|
||
get_value_or(name, task_json, "specificRect", task_info_ptr->specific_rect, default_ptr->specific_rect);
|
||
get_value_or(name, task_json, "specialParams", task_info_ptr->special_params, default_ptr->special_params);
|
||
#ifdef ASST_DEBUG
|
||
// Debug 模式下检查 roi 是否超出边界
|
||
if (auto [x, y, w, h] = task_info_ptr->roi; x + w > WindowWidthDefault || y + h > WindowHeightDefault) {
|
||
Log.warn(name, "roi is out of bounds");
|
||
}
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
std::shared_ptr<asst::MatchTaskInfo> asst::TaskData::_default_match_task_info()
|
||
{
|
||
auto match_task_info_ptr = std::make_shared<MatchTaskInfo>();
|
||
match_task_info_ptr->templ_names = { "__INVALID__" };
|
||
match_task_info_ptr->templ_thresholds = { TemplThresholdDefault };
|
||
|
||
return match_task_info_ptr;
|
||
}
|
||
|
||
std::shared_ptr<asst::OcrTaskInfo> asst::TaskData::_default_ocr_task_info()
|
||
{
|
||
auto ocr_task_info_ptr = std::make_shared<OcrTaskInfo>();
|
||
ocr_task_info_ptr->full_match = false;
|
||
ocr_task_info_ptr->is_ascii = false;
|
||
ocr_task_info_ptr->without_det = false;
|
||
ocr_task_info_ptr->replace_full = false;
|
||
|
||
return ocr_task_info_ptr;
|
||
}
|
||
|
||
std::shared_ptr<asst::HashTaskInfo> asst::TaskData::_default_hash_task_info()
|
||
{
|
||
auto hash_task_info_ptr = std::make_shared<HashTaskInfo>();
|
||
hash_task_info_ptr->dist_threshold = 0;
|
||
hash_task_info_ptr->bound = true;
|
||
|
||
return hash_task_info_ptr;
|
||
}
|
||
|
||
asst::TaskData::taskptr_t asst::TaskData::_default_task_info()
|
||
{
|
||
auto task_info_ptr = std::make_shared<TaskInfo>();
|
||
task_info_ptr->algorithm = AlgorithmType::MatchTemplate;
|
||
task_info_ptr->action = ProcessTaskAction::DoNothing;
|
||
task_info_ptr->cache = true;
|
||
task_info_ptr->max_times = INT_MAX;
|
||
task_info_ptr->pre_delay = 0;
|
||
task_info_ptr->post_delay = 0;
|
||
task_info_ptr->roi = Rect();
|
||
task_info_ptr->sub_error_ignored = false;
|
||
task_info_ptr->rect_move = Rect();
|
||
task_info_ptr->specific_rect = Rect();
|
||
|
||
return task_info_ptr;
|
||
}
|
||
|
||
// new_tasks 是目的任务列表
|
||
// raw_tasks 是源任务表达式列表
|
||
// task_name 是任务名
|
||
// task_changed 记录 raw_tasks 在转换为 new_tasks 时是否发生变化
|
||
// allow_duplicate 是否允许重复
|
||
bool asst::TaskData::compile_tasklist(tasklist_t& new_tasks, const tasklist_t& raw_tasks, std::string_view task_name,
|
||
bool& task_changed, bool allow_duplicate)
|
||
{
|
||
std::unordered_set<std::string_view> tasks_set; // 记录任务列表中已有的任务（内容元素与 new_tasks 基本一致）
|
||
|
||
using symbl_t = size_t;
|
||
[[maybe_unused]] constexpr symbl_t symbl_end = 0;
|
||
[[maybe_unused]] constexpr symbl_t symbl_lambda_task_sep = 1;
|
||
[[maybe_unused]] constexpr symbl_t symbl_lparen = 2;
|
||
[[maybe_unused]] constexpr symbl_t symbl_rparen = 3;
|
||
[[maybe_unused]] constexpr symbl_t symbl_lbrace = 4;
|
||
[[maybe_unused]] constexpr symbl_t symbl_rbrace = 5;
|
||
[[maybe_unused]] constexpr symbl_t symbl_at = 6;
|
||
[[maybe_unused]] constexpr symbl_t symbl_sharp = 7;
|
||
[[maybe_unused]] constexpr symbl_t symbl_mul = 8;
|
||
[[maybe_unused]] constexpr symbl_t symbl_add = 9;
|
||
[[maybe_unused]] constexpr symbl_t symbl_sub = 10;
|
||
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_start = 11;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_sub = 11;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_next = 12;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_on_error_next = 13;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_exceeded_next = 14;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_reduce_other_times = 15;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_self = 16;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_back = 17;
|
||
[[maybe_unused]] constexpr symbl_t symbl_name_none = 18;
|
||
|
||
static const std::vector<std::string> symbl_table = {
|
||
"__END__", // 0
|
||
",", // 1
|
||
"(", // 2
|
||
")", // 3
|
||
"{", // 4
|
||
"}", // 5
|
||
"@", // 6
|
||
"#", // 7
|
||
"*", // 8
|
||
"+", // 9
|
||
"^", // 10
|
||
"sub", // 11
|
||
"next", // 12
|
||
"on_error_next", // 13
|
||
"exceeded_next", // 14
|
||
"reduce_other_times", // 15
|
||
"self", // 16
|
||
"back", // 17
|
||
"none", // 18
|
||
};
|
||
|
||
auto is_symbl_name = [&](symbl_t x) { return x >= symbl_name_start; };
|
||
auto is_symbl_subtask_type = [&](symbl_t x) {
|
||
switch (x) {
|
||
case symbl_name_sub:
|
||
case symbl_name_next:
|
||
case symbl_name_on_error_next:
|
||
case symbl_name_exceeded_next:
|
||
case symbl_name_reduce_other_times:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
[[maybe_unused]] auto is_symbl_sharp_type = [&](symbl_t x) {
|
||
switch (x) {
|
||
case symbl_name_self:
|
||
case symbl_name_back:
|
||
case symbl_name_none:
|
||
return true;
|
||
default:
|
||
return is_symbl_subtask_type(x);
|
||
}
|
||
};
|
||
|
||
// perform_op 的结果不保证符合参数 multi 的要求
|
||
auto perform_op = [&](std::string_view task_expr, symbl_t op, tasklistptr_t x,
|
||
tasklistptr_t y) -> std::optional<asst::TaskData::tasklistptr_t> {
|
||
auto ret = std::make_shared<tasklist_t>();
|
||
|
||
switch (op) {
|
||
case symbl_add:
|
||
ranges::copy(*x, std::back_inserter(*ret));
|
||
ranges::copy(*y, std::back_inserter(*ret));
|
||
break;
|
||
case symbl_sub:
|
||
for (std::string_view sx : *x) {
|
||
bool flag = true;
|
||
for (std::string_view sy : *y) {
|
||
if (sx == sy) {
|
||
flag = false;
|
||
break;
|
||
}
|
||
}
|
||
if (flag) ret->emplace_back(sx);
|
||
}
|
||
break;
|
||
case symbl_mul: {
|
||
if (y->size() != 1) {
|
||
Log.error("There is more than one y:", *y, "while perform op", symbl_table[op], "in", task_expr,
|
||
"of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
int times = 0;
|
||
try {
|
||
times = std::stoi(y->front());
|
||
}
|
||
catch (...) {
|
||
Log.error("y:", y->front(), "is not number while perform op", symbl_table[op], "in", task_expr,
|
||
"of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
for (int i = 0; i < times; ++i) {
|
||
ranges::copy(*x, std::back_inserter(*ret));
|
||
}
|
||
break;
|
||
}
|
||
case symbl_at: {
|
||
if (y->empty()) { // A@#none = A
|
||
ranges::copy(*x, std::back_inserter(*ret));
|
||
}
|
||
else if (x->empty()) { // #none@A = A
|
||
ranges::copy(*y, std::back_inserter(*ret));
|
||
}
|
||
else { // (A+B)@(C+D) = A@C + A@D + B@C + B@D
|
||
ranges::for_each(
|
||
*x, [&](std::string_view s) { ranges::copy(append_prefix(*y, s), std::back_inserter(*ret)); });
|
||
}
|
||
break;
|
||
}
|
||
case symbl_sharp: {
|
||
if (y->empty()) {
|
||
Log.error("There is no sharp_type while perform op", symbl_table[op], "in", task_expr,
|
||
"of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
for (std::string_view type : *y) {
|
||
if (!x || x->empty()) { // unary
|
||
x = std::make_shared<tasklist_t>(tasklist_t { "" });
|
||
}
|
||
for (const auto& task : *x) {
|
||
if (type == "self") {
|
||
ret->emplace_back(task_name);
|
||
continue;
|
||
}
|
||
if (type == "none") {
|
||
continue;
|
||
}
|
||
if (type == "back") {
|
||
// "A#back" === "A", "B@A#back" === "B@A", "#back" === null
|
||
if (!task.empty()) ret->emplace_back(task);
|
||
continue;
|
||
}
|
||
taskptr_t other_task_info_ptr = task.empty() ? default_task_info_ptr : get_raw(task);
|
||
|
||
#define ASST_TASKDATA_PERFORM_OP_IF_BRANCH(t, m) \
|
||
else if (type == #t) \
|
||
{ \
|
||
bool task_changed = false; \
|
||
if (!compile_tasklist(*ret, other_task_info_ptr->t, task_name, task_changed, m)) { \
|
||
Log.error("Failed to compile task", task + "->" #t, "while perform op", symbl_table[op], "in", task_expr, \
|
||
"of task:", task_name); \
|
||
return std::nullopt; \
|
||
} \
|
||
}
|
||
if (other_task_info_ptr == nullptr) [[unlikely]] {
|
||
Log.error("Task", task, "not found while perform op", symbl_table[op], "in", task_expr,
|
||
"of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
ASST_TASKDATA_PERFORM_OP_IF_BRANCH(next, false)
|
||
ASST_TASKDATA_PERFORM_OP_IF_BRANCH(sub, true)
|
||
ASST_TASKDATA_PERFORM_OP_IF_BRANCH(on_error_next, false)
|
||
ASST_TASKDATA_PERFORM_OP_IF_BRANCH(exceeded_next, false)
|
||
ASST_TASKDATA_PERFORM_OP_IF_BRANCH(reduce_other_times, true)
|
||
else [[unlikely]]
|
||
{
|
||
Log.error("Unknown symbol", type, "while perform op", symbl_table[op], "in", task_expr,
|
||
"of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
#undef ASST_TASKDATA_PERFORM_OP_IF_BRANCH
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
default:
|
||
Log.error("Unknown op", symbl_table[op], "in", task_expr, "of task:", task_name);
|
||
return std::nullopt;
|
||
}
|
||
return ret;
|
||
};
|
||
|
||
for (std::string_view task_expr : raw_tasks) {
|
||
if (task_expr.empty() || (!allow_duplicate && tasks_set.contains(task_expr))) {
|
||
task_changed = true;
|
||
continue;
|
||
}
|
||
|
||
std::vector<std::string> symbols_table = symbl_table;
|
||
|
||
std::unordered_map<std::string, symbl_t> symbols_id = {};
|
||
for (symbl_t i = 0; i != symbols_table.size(); ++i) {
|
||
symbols_id.emplace(symbols_table[i], i);
|
||
}
|
||
|
||
std::vector<symbl_t> symbol_stream;
|
||
auto emplace_symbol_if_not_empty = [&](const auto l, const auto r) {
|
||
if (l < r) {
|
||
auto symbol = std::string(l, r);
|
||
if (!symbols_id.contains(symbol)) {
|
||
symbl_t id = symbols_table.size();
|
||
symbols_id.emplace(symbol, id);
|
||
symbols_table.emplace_back(symbol);
|
||
symbol_stream.emplace_back(id);
|
||
}
|
||
else {
|
||
symbol_stream.emplace_back(symbols_id[symbol]);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 记号流分析
|
||
auto y_begin = task_expr.begin();
|
||
for (auto p = task_expr.begin(); p != task_expr.end(); ++p) {
|
||
switch (*p) {
|
||
case ' ':
|
||
case '\t':
|
||
case '\r':
|
||
case '\n':
|
||
emplace_symbol_if_not_empty(y_begin, p);
|
||
y_begin = p + 1;
|
||
break;
|
||
case ',':
|
||
case '(':
|
||
case ')':
|
||
case '{':
|
||
case '}':
|
||
case '#':
|
||
case '*':
|
||
case '+':
|
||
case '^':
|
||
task_changed = true;
|
||
[[fallthrough]];
|
||
case '@':
|
||
emplace_symbol_if_not_empty(y_begin, p);
|
||
y_begin = p + 1;
|
||
symbol_stream.emplace_back(symbols_id[std::string(1, *p)]);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
emplace_symbol_if_not_empty(y_begin, task_expr.end());
|
||
symbol_stream.emplace_back(symbl_end); // 结束符
|
||
// Log.debug(symbol_stream | views::transform([&](symbl_t id) { return symbols_table[id]; }));
|
||
// Log.debug(symbol_stream);
|
||
|
||
/*
|
||
$name = 至少一位的任务名
|
||
$numbers = 至少一位的数字
|
||
|
||
$subtask_type = sub
|
||
| next
|
||
| on_error_next
|
||
| exceeded_next
|
||
| reduce_other_times
|
||
|
||
$sharp_type = $subtask_type
|
||
| self
|
||
| back
|
||
| none
|
||
|
||
$subtask = $subtask_type ( $tasks )
|
||
|
||
$lambda_task = { $subtask , ... } // 暂未实现
|
||
| { $tasks } // 暂未实现；不写 subtask_type 默认为 sub
|
||
|
||
$parens = # $sharp_type
|
||
| $name
|
||
| $name $lambda_task // 暂未实现
|
||
| ( $tasks )
|
||
|
||
$top_tasks = $top_tasks @ $parens
|
||
| $top_tasks # $sharp_type
|
||
| $parens
|
||
|
||
$mul_tasks = $top_tasks * $numbers
|
||
| $top_tasks
|
||
|
||
$tasks = $mul_tasks + $tasks
|
||
| $mul_tasks ^ $tasks // 删除 $mul_tasks 中所有在 $tasks 中的任务
|
||
| $mul_tasks
|
||
*/
|
||
// 记号流处理
|
||
auto cur = symbol_stream.cbegin();
|
||
using decode_func_t = std::function<std::optional<tasklistptr_t>()>;
|
||
decode_func_t decode_name, decode_tasks, decode_multasks, decode_vtasks, decode_parens;
|
||
decode_name = [&]() -> std::optional<tasklistptr_t> {
|
||
if (is_symbl_name(*cur)) {
|
||
return std::make_shared<tasklist_t>(tasklist_t { symbols_table[*(cur++)] });
|
||
}
|
||
return std::nullopt;
|
||
};
|
||
decode_tasks = [&]() -> std::optional<tasklistptr_t> {
|
||
auto l = decode_multasks();
|
||
if (!l) return std::nullopt;
|
||
while (*cur == symbl_add || *cur == symbl_sub) {
|
||
symbl_t op = *(cur++);
|
||
auto r = decode_multasks();
|
||
if (!r) return std::nullopt;
|
||
l = perform_op(task_expr, op, *l, *r);
|
||
if (!l) return std::nullopt;
|
||
}
|
||
return l;
|
||
};
|
||
decode_multasks = [&]() -> std::optional<tasklistptr_t> {
|
||
auto l = decode_vtasks();
|
||
if (!l) return std::nullopt;
|
||
while (*cur == symbl_mul) {
|
||
symbl_t op = *(cur++);
|
||
auto r = decode_name();
|
||
if (!r) return std::nullopt;
|
||
l = perform_op(task_expr, op, *l, *r);
|
||
if (!l) return std::nullopt;
|
||
}
|
||
return l;
|
||
};
|
||
decode_vtasks = [&]() -> std::optional<tasklistptr_t> {
|
||
auto l = decode_parens();
|
||
if (!l) return std::nullopt;
|
||
while (*cur == symbl_at || *cur == symbl_sharp) {
|
||
symbl_t op = *(cur++);
|
||
auto r = decode_parens();
|
||
if (!r) return std::nullopt;
|
||
l = perform_op(task_expr, op, *l, *r);
|
||
if (!l) return std::nullopt;
|
||
}
|
||
return l;
|
||
};
|
||
decode_parens = [&]() -> std::optional<tasklistptr_t> {
|
||
if (*cur == symbl_lparen) {
|
||
++cur;
|
||
auto l = decode_tasks();
|
||
if (!l) return std::nullopt;
|
||
if (*cur != symbl_rparen) [[unlikely]] {
|
||
Log.error("Invalid symbol", *cur, "at", cur - symbol_stream.cbegin(), "in", symbol_stream,
|
||
"(should be ')')");
|
||
return std::nullopt;
|
||
}
|
||
++cur;
|
||
return l;
|
||
}
|
||
if (*cur == symbl_sharp) {
|
||
++cur;
|
||
auto r = decode_name();
|
||
if (!r) return std::nullopt;
|
||
return perform_op(task_expr, symbl_sharp, nullptr, *r);
|
||
}
|
||
if (is_symbl_name(*cur)) {
|
||
return decode_name();
|
||
}
|
||
Log.error("Invalid symbol", *cur, "at", cur - symbol_stream.cbegin(), "in", symbol_stream);
|
||
return std::nullopt;
|
||
};
|
||
auto opt = decode_tasks();
|
||
if (!opt || (*cur != symbl_end && cur != symbol_stream.cend())) {
|
||
return false;
|
||
}
|
||
|
||
for (const auto& task : **opt) {
|
||
if (task.empty() || (!allow_duplicate && tasks_set.contains(task))) {
|
||
task_changed = true;
|
||
continue;
|
||
}
|
||
new_tasks.emplace_back(task);
|
||
tasks_set.emplace(task_name_view(task));
|
||
}
|
||
|
||
tasks_set.emplace(task_name_view(task_expr));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
#ifdef ASST_DEBUG
|
||
// 为了解决类似 beddc7c828126c678391e0b4da288db6d2c2d58a 导致的问题，加载的时候做一个语法检查
|
||
// 主要是处理是否包含未知键值的问题
|
||
bool asst::TaskData::syntax_check(std::string_view task_name, const json::value& task_json)
|
||
{
|
||
// clang-format off
|
||
// 以下按字典序排序
|
||
static const std::unordered_map<AlgorithmType, std::unordered_set<std::string>> allowed_key_under_algorithm = {
|
||
{ AlgorithmType::Invalid,
|
||
{
|
||
"action", "algorithm", "baseTask", "cache", "exceededNext", "fullMatch",
|
||
"hash", "isAscii", "maskRange", "maxTimes", "next", "ocrReplace",
|
||
"onErrorNext", "postDelay", "preDelay", "rectMove", "reduceOtherTimes", "replaceFull",
|
||
"roi", "specialParams", "sub", "subErrorIgnored", "templThreshold", "template",
|
||
"text", "threshold", "withoutDet",
|
||
} },
|
||
{ AlgorithmType::MatchTemplate,
|
||
{
|
||
"action", "algorithm", "baseTask", "cache", "exceededNext", "maskRange",
|
||
"maxTimes", "next", "onErrorNext", "postDelay", "preDelay", "rectMove",
|
||
"reduceOtherTimes", "roi", "sub", "subErrorIgnored", "templThreshold", "template",
|
||
"specialParams",
|
||
} },
|
||
{ AlgorithmType::OcrDetect,
|
||
{
|
||
"action", "algorithm", "baseTask", "cache", "exceededNext", "fullMatch",
|
||
"isAscii", "maxTimes", "next", "ocrReplace", "onErrorNext", "postDelay",
|
||
"preDelay", "rectMove", "reduceOtherTimes", "replaceFull", "roi", "sub",
|
||
"subErrorIgnored", "text", "withoutDet", "specialParams",
|
||
} },
|
||
{ AlgorithmType::JustReturn,
|
||
{
|
||
"action", "algorithm", "baseTask", "exceededNext", "maxTimes", "next",
|
||
"onErrorNext", "postDelay", "preDelay", "reduceOtherTimes", "specialParams", "sub",
|
||
"subErrorIgnored",
|
||
} },
|
||
{ AlgorithmType::Hash,
|
||
{
|
||
"action", "algorithm", "baseTask", "cache", "exceededNext", "hash",
|
||
"maskRange", "maxTimes", "next", "onErrorNext", "postDelay", "preDelay",
|
||
"rectMove", "reduceOtherTimes", "roi", "specialParams", "sub", "subErrorIgnored",
|
||
"threshold",
|
||
} },
|
||
};
|
||
// clang-format on
|
||
|
||
static const std::unordered_map<ProcessTaskAction, std::unordered_set<std::string>> allowed_key_under_action = {
|
||
{ ProcessTaskAction::ClickRect, { "specificRect" } },
|
||
{ ProcessTaskAction::Swipe, { "specificRect", "rectMove" } },
|
||
};
|
||
|
||
auto is_doc = [&](std::string_view key) {
|
||
return key.find("Doc") != std::string_view::npos || key.find("doc") != std::string_view::npos;
|
||
};
|
||
|
||
// 兜底策略，如果某个 key ("xxx") 不符合规范（可能是代码中使用到的参数，而不是任务流程）
|
||
// 需要加一个注释 ("xxx_Doc") 就能过 syntax_check.
|
||
auto has_doc = [&](const std::string& key) -> bool {
|
||
return task_json.find(key + "_Doc") || task_json.find(key + "_doc");
|
||
};
|
||
|
||
if (!task_json.is_object()) {
|
||
Log.error(task_name, "is not a json object.");
|
||
return false;
|
||
}
|
||
|
||
bool validity = true;
|
||
auto task_ptr = get(task_name);
|
||
if (task_ptr == nullptr) {
|
||
Log.error("TaskData::syntax_check | Task", task_name, "has not been generated.");
|
||
return false;
|
||
}
|
||
|
||
// 获取 algorithm
|
||
auto algorithm = task_ptr->algorithm;
|
||
if (algorithm == AlgorithmType::Invalid) [[unlikely]] {
|
||
Log.error(task_name, "has unknown algorithm.");
|
||
validity = false;
|
||
}
|
||
|
||
// 获取 action
|
||
auto action = task_ptr->action;
|
||
if (action == ProcessTaskAction::Invalid) [[unlikely]] {
|
||
Log.error(task_name, "has unknown action.");
|
||
validity = false;
|
||
}
|
||
|
||
std::unordered_set<std::string> allowed_key {};
|
||
if (allowed_key_under_algorithm.contains(algorithm)) {
|
||
decltype(allowed_key) tmp = allowed_key_under_algorithm.at(algorithm);
|
||
allowed_key.merge(tmp);
|
||
}
|
||
if (allowed_key_under_action.contains(action)) {
|
||
decltype(allowed_key) tmp = allowed_key_under_action.at(action);
|
||
allowed_key.merge(tmp);
|
||
}
|
||
|
||
for (const auto& name : task_json.as_object() | views::keys) {
|
||
if (!allowed_key.contains(name) && !is_doc(name) && !has_doc(name)) {
|
||
Log.error(task_name, "has unknown key:", name);
|
||
validity = false;
|
||
}
|
||
}
|
||
return validity;
|
||
}
|
||
#endif
|