2291 lines
87 KiB
C++
2291 lines
87 KiB
C++
#include <algorithm>
|
||
#include <cctype>
|
||
#include <cerrno>
|
||
#include <cmath>
|
||
#include <cstdlib>
|
||
#include <filesystem>
|
||
#include <fstream>
|
||
#include <iomanip>
|
||
#include <functional>
|
||
#include <limits>
|
||
#include <iostream>
|
||
#include <map>
|
||
#include <regex>
|
||
#include <set>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
#include <unordered_set>
|
||
#include <vector>
|
||
|
||
#include "json.hpp" // nlohmann::json (单头文件版)
|
||
#include "pq_app.h"
|
||
#include "tinyxml2.h" // tinyxml2
|
||
|
||
using json = nlohmann::json;
|
||
namespace fs = std::filesystem;
|
||
|
||
struct ValueMeta {
|
||
std::string name;
|
||
std::string desc;
|
||
std::string doPath;
|
||
std::string daPath;
|
||
std::string wiring = "common"; // star/delta/common
|
||
std::string topic;
|
||
std::string dataType;
|
||
std::string itemName;
|
||
std::string seqValue;
|
||
bool hasOffset = false;
|
||
int offset = 0;
|
||
|
||
bool isSequence = false;
|
||
int seqStart = 0; // 例如 %2,50% 里的 2
|
||
int seqEnd = 0; // 例如 %2,50% 里的 50
|
||
std::string seqPrefixName; // 例如 MAX_V
|
||
};
|
||
|
||
static std::string readAll(const fs::path& p) {
|
||
std::ifstream ifs(p, std::ios::binary);
|
||
if (!ifs) throw std::runtime_error("Failed to open: " + p.string());
|
||
std::ostringstream oss;
|
||
oss << ifs.rdbuf();
|
||
return oss.str();
|
||
}
|
||
|
||
static std::string ltrimBOM(std::string s) {
|
||
const std::string bom = "\xEF\xBB\xBF";
|
||
if (s.rfind(bom, 0) == 0) s.erase(0, bom.size());
|
||
return s;
|
||
}
|
||
|
||
static std::string collapseRepeatedAlternatives(const std::string& s) {
|
||
std::vector<std::string> parts;
|
||
std::unordered_set<std::string> seen;
|
||
size_t start = 0;
|
||
while (true) {
|
||
size_t pos = s.find("||", start);
|
||
std::string part = pos == std::string::npos ? s.substr(start) : s.substr(start, pos - start);
|
||
if (!seen.count(part)) {
|
||
seen.insert(part);
|
||
parts.push_back(part);
|
||
}
|
||
if (pos == std::string::npos) break;
|
||
start = pos + 2;
|
||
}
|
||
std::ostringstream oss;
|
||
for (size_t i = 0; i < parts.size(); ++i) {
|
||
if (i) oss << "||";
|
||
oss << parts[i];
|
||
}
|
||
return oss.str();
|
||
}
|
||
|
||
static std::string toStr(const json& v) {
|
||
if (v.is_null()) return "null";
|
||
if (v.is_boolean()) return v.get<bool>() ? "true" : "false";
|
||
if (v.is_number_integer()) return std::to_string(v.get<long long>());
|
||
if (v.is_number_unsigned()) return std::to_string(v.get<unsigned long long>());
|
||
if (v.is_number_float()) {
|
||
std::ostringstream oss;
|
||
oss.setf(std::ios::fixed);
|
||
oss.precision(6);
|
||
oss << v.get<double>();
|
||
std::string s = oss.str();
|
||
while (s.find('.') != std::string::npos && !s.empty() && s.back() == '0') s.pop_back();
|
||
if (!s.empty() && s.back() == '.') s.pop_back();
|
||
if (s.empty()) s = "0";
|
||
return s;
|
||
}
|
||
if (v.is_string()) return v.get<std::string>();
|
||
return v.dump();
|
||
}
|
||
|
||
static void flattenJson(const json& j, const std::string& prefix,
|
||
std::vector<std::pair<std::string, std::string>>& out) {
|
||
if (j.is_object()) {
|
||
for (auto it = j.begin(); it != j.end(); ++it) {
|
||
std::string key = prefix.empty() ? it.key() : (prefix + "_" + it.key());
|
||
flattenJson(it.value(), key, out);
|
||
}
|
||
return;
|
||
}
|
||
if (j.is_array()) {
|
||
std::ostringstream oss;
|
||
for (size_t i = 0; i < j.size(); ++i) {
|
||
if (i) oss << ",";
|
||
oss << toStr(j[i]);
|
||
}
|
||
out.push_back({prefix, oss.str()});
|
||
return;
|
||
}
|
||
out.push_back({prefix, toStr(j)});
|
||
}
|
||
|
||
// 读取 XML：Value/@name -> 完整元信息（desc/DO/DA）
|
||
static std::unordered_map<std::string, std::vector<ValueMeta>> loadValueMetas(const fs::path& xmlPath) {
|
||
std::unordered_map<std::string, std::vector<ValueMeta>> mp;
|
||
tinyxml2::XMLDocument doc;
|
||
|
||
std::string xmlContent = readAll(xmlPath);
|
||
|
||
if (doc.Parse(xmlContent.c_str()) != tinyxml2::XML_SUCCESS) {
|
||
throw std::runtime_error("Failed to parse xml: " + xmlPath.string());
|
||
}
|
||
|
||
std::regex seqRe(R"(^(.*)%(\d+),(\d+)%$)");
|
||
|
||
std::function<void(tinyxml2::XMLElement*, std::string, std::string, std::string, std::string, std::string)> walk =
|
||
[&](tinyxml2::XMLElement* e,
|
||
std::string wiring,
|
||
std::string topic,
|
||
std::string dataType,
|
||
std::string itemName,
|
||
std::string seqValue) {
|
||
for (; e; e = e->NextSiblingElement()) {
|
||
std::string nodeName = e->Name() ? e->Name() : "";
|
||
std::string nextWiring = wiring;
|
||
std::string nextTopic = topic;
|
||
std::string nextDataType = dataType;
|
||
std::string nextItemName = itemName;
|
||
std::string nextSeqValue = seqValue;
|
||
if (nodeName == "Topic") {
|
||
const char* name = e->Attribute("name");
|
||
nextTopic = name ? name : "";
|
||
} else if (nodeName == "DataType") {
|
||
const char* value = e->Attribute("value");
|
||
nextDataType = value ? value : "";
|
||
} else if (nodeName == "Item") {
|
||
const char* name = e->Attribute("name");
|
||
nextItemName = name ? name : "";
|
||
}
|
||
if (nodeName == "Sequence") {
|
||
const char* seqValue = e->Attribute("value");
|
||
nextSeqValue = seqValue ? seqValue : "";
|
||
if (seqValue && std::string(seqValue) == "7") nextWiring = "star";
|
||
else if (seqValue && std::string(seqValue) == "112") nextWiring = "delta";
|
||
}
|
||
|
||
if (nodeName == "Value") {
|
||
const char* name = e->Attribute("name");
|
||
const char* desc = e->Attribute("desc");
|
||
const char* doPath = e->Attribute("DO");
|
||
const char* daPath = e->Attribute("DA");
|
||
const char* offset = e->Attribute("Offset");
|
||
|
||
if (name) {
|
||
ValueMeta vm;
|
||
vm.name = name;
|
||
vm.desc = desc ? desc : "";
|
||
vm.doPath = doPath ? collapseRepeatedAlternatives(doPath) : "";
|
||
vm.daPath = daPath ? collapseRepeatedAlternatives(daPath) : "";
|
||
vm.wiring = nextWiring;
|
||
vm.topic = nextTopic;
|
||
vm.dataType = nextDataType;
|
||
vm.itemName = nextItemName;
|
||
vm.seqValue = nextSeqValue;
|
||
if (offset) {
|
||
vm.hasOffset = true;
|
||
vm.offset = std::stoi(offset);
|
||
}
|
||
|
||
std::smatch m;
|
||
if (std::regex_match(vm.name, m, seqRe)) {
|
||
vm.isSequence = true;
|
||
vm.seqPrefixName = m[1].str(); // 例如 MAX_V
|
||
vm.seqStart = std::stoi(m[2].str());
|
||
vm.seqEnd = std::stoi(m[3].str());
|
||
}
|
||
|
||
mp[vm.name].push_back(vm);
|
||
}
|
||
}
|
||
walk(e->FirstChildElement(), nextWiring, nextTopic, nextDataType, nextItemName, nextSeqValue);
|
||
}
|
||
};
|
||
|
||
walk(doc.RootElement(), "common", "", "", "", "");
|
||
return mp;
|
||
}
|
||
|
||
// 相位
|
||
static const std::vector<std::string> PHASES = {"A", "B", "C", "T"};
|
||
static std::unordered_map<std::string, int> phaseRank() {
|
||
std::unordered_map<std::string, int> m;
|
||
for (int i = 0; i < (int)PHASES.size(); ++i) m[PHASES[i]] = i;
|
||
return m;
|
||
}
|
||
|
||
// 从 key 中提取 “相位之后的 metricName”
|
||
// 例如：Value_V_A_MAX_V1 -> MAX_V1
|
||
static std::string metricAfterPhase(const std::string& key) {
|
||
std::string base = key;
|
||
auto bpos = base.find('[');
|
||
if (bpos != std::string::npos) base = base.substr(0, bpos);
|
||
|
||
std::vector<std::string> parts;
|
||
std::stringstream ss(base);
|
||
std::string tok;
|
||
while (std::getline(ss, tok, '_')) parts.push_back(tok);
|
||
|
||
auto pr = phaseRank();
|
||
int lastPhaseI = -1;
|
||
for (int i = 0; i < (int)parts.size(); ++i) {
|
||
if (pr.find(parts[i]) != pr.end()) lastPhaseI = i;
|
||
}
|
||
if (lastPhaseI == -1 || lastPhaseI + 1 >= (int)parts.size()) return "";
|
||
|
||
std::string m = parts[lastPhaseI + 1];
|
||
for (int i = lastPhaseI + 2; i < (int)parts.size(); ++i) m += "_" + parts[i];
|
||
return m;
|
||
}
|
||
|
||
// 尝试把 key 识别成序列：
|
||
// 1) ..._<number>
|
||
// 2) ..._<LETTERS><number> (如 ..._V2, ..._VA50)
|
||
static bool parseSequenceKey(const std::string& key, std::string& groupId, int& idx) {
|
||
auto posBracket = key.find('[');
|
||
std::string base = (posBracket == std::string::npos) ? key : key.substr(0, posBracket);
|
||
|
||
static const std::regex re_underscore_num(R"(^(.*)_(\d+)$)");
|
||
static const std::regex re_letters_num(R"(^([A-Za-z]+)(\d+)$)");
|
||
|
||
std::smatch m;
|
||
if (std::regex_match(base, m, re_underscore_num)) {
|
||
groupId = m[1].str();
|
||
idx = std::stoi(m[2].str());
|
||
return true;
|
||
}
|
||
|
||
auto lastUnd = base.rfind('_');
|
||
if (lastUnd != std::string::npos) {
|
||
std::string pre = base.substr(0, lastUnd);
|
||
std::string last = base.substr(lastUnd + 1);
|
||
std::smatch m2;
|
||
if (std::regex_match(last, m2, re_letters_num)) {
|
||
groupId = pre + "_" + m2[1].str();
|
||
idx = std::stoi(m2[2].str());
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ✅ 合并序列：但如果 metricName 在 xmlNames 里存在（比如 V1/MAX_V1/G_V1），则禁止合并
|
||
static std::vector<std::pair<std::string, std::string>>
|
||
mergeSequences(const std::vector<std::pair<std::string, std::string>>& flat,
|
||
const std::unordered_set<std::string>& xmlNames) {
|
||
struct SeqGroup { size_t firstPos; std::map<int, std::string> idx2val; };
|
||
|
||
std::unordered_map<std::string, SeqGroup> groups;
|
||
std::vector<bool> isSeq(flat.size(), false);
|
||
std::vector<std::string> key2group(flat.size());
|
||
|
||
for (size_t i = 0; i < flat.size(); ++i) {
|
||
const auto& k = flat[i].first;
|
||
|
||
// ✅ 如果 XML 定义了该指标（例如 V1/MAX_V1/...），就不要当作序列
|
||
std::string mname = metricAfterPhase(k);
|
||
if (!mname.empty() && xmlNames.count(mname)) {
|
||
continue;
|
||
}
|
||
|
||
std::string gid; int idx = 0;
|
||
if (parseSequenceKey(k, gid, idx)) {
|
||
isSeq[i] = true;
|
||
key2group[i] = gid;
|
||
auto& g = groups[gid];
|
||
if (g.idx2val.empty()) g.firstPos = i;
|
||
g.idx2val[idx] = flat[i].second;
|
||
}
|
||
}
|
||
|
||
std::unordered_map<std::string, bool> mergeable;
|
||
for (auto& kv : groups) {
|
||
mergeable[kv.first] = (kv.second.idx2val.size() >= 2);
|
||
}
|
||
|
||
std::vector<std::pair<std::string, std::string>> out;
|
||
std::unordered_map<std::string, bool> emitted;
|
||
|
||
for (size_t i = 0; i < flat.size(); ++i) {
|
||
if (isSeq[i] && mergeable[key2group[i]]) {
|
||
const std::string& gid = key2group[i];
|
||
if (emitted[gid]) continue;
|
||
emitted[gid] = true;
|
||
|
||
const auto& g = groups[gid];
|
||
int start = g.idx2val.begin()->first;
|
||
int end = g.idx2val.rbegin()->first;
|
||
|
||
std::ostringstream oss;
|
||
for (int x = start; x <= end; ++x) {
|
||
if (x != start) oss << ",";
|
||
auto it = g.idx2val.find(x);
|
||
oss << (it == g.idx2val.end() ? "null" : it->second);
|
||
}
|
||
|
||
std::ostringstream key;
|
||
key << gid << "[" << start << "-" << end << "]";
|
||
out.push_back({key.str(), oss.str()});
|
||
} else {
|
||
out.push_back(flat[i]);
|
||
}
|
||
}
|
||
|
||
return out;
|
||
}
|
||
|
||
struct ParsedKey {
|
||
std::string phase; // A/B/C/T/""
|
||
std::string stat; // 95值/平均值/最大值/最小值
|
||
std::string baseName; // 去掉 G_/MAX_/MIN_ 后的 name
|
||
};
|
||
|
||
static ParsedKey parseForSort(const std::string& key) {
|
||
std::string base = key;
|
||
auto bpos = base.find('[');
|
||
if (bpos != std::string::npos) base = base.substr(0, bpos);
|
||
|
||
std::vector<std::string> parts;
|
||
std::stringstream ss(base);
|
||
std::string tok;
|
||
while (std::getline(ss, tok, '_')) parts.push_back(tok);
|
||
|
||
auto pr = phaseRank();
|
||
int lastPhaseI = -1;
|
||
std::string phase;
|
||
for (int i = 0; i < (int)parts.size(); ++i) {
|
||
if (pr.find(parts[i]) != pr.end()) {
|
||
lastPhaseI = i;
|
||
phase = parts[i];
|
||
}
|
||
}
|
||
|
||
std::string metric;
|
||
if (lastPhaseI != -1 && lastPhaseI + 1 < (int)parts.size()) {
|
||
metric = parts[lastPhaseI + 1];
|
||
for (int i = lastPhaseI + 2; i < (int)parts.size(); ++i) metric += "_" + parts[i];
|
||
} else {
|
||
metric = parts.empty() ? "" : parts.back();
|
||
}
|
||
|
||
ParsedKey pk;
|
||
pk.phase = phase;
|
||
pk.stat = "平均值";
|
||
pk.baseName = metric;
|
||
|
||
auto startsWith = [&](const std::string& s, const std::string& pre) {
|
||
return s.size() >= pre.size() && s.compare(0, pre.size(), pre) == 0;
|
||
};
|
||
|
||
if (startsWith(metric, "G_")) { pk.stat = "95值"; pk.baseName = metric.substr(2); }
|
||
else if (startsWith(metric, "MAX_")) { pk.stat = "最大值"; pk.baseName = metric.substr(4); }
|
||
else if (startsWith(metric, "MIN_")) { pk.stat = "最小值"; pk.baseName = metric.substr(4); }
|
||
|
||
return pk;
|
||
}
|
||
|
||
static std::string cleanDescSuffix(std::string desc) {
|
||
static const std::regex re(R"((平均值|最大值|最小值|95值)$)");
|
||
return std::regex_replace(desc, re, "");
|
||
}
|
||
|
||
static int getDisplayWidth(const std::string& s) {
|
||
int w = 0;
|
||
for (size_t i = 0; i < s.size(); ) {
|
||
unsigned char c = static_cast<unsigned char>(s[i]);
|
||
|
||
if (c < 0x80) { // ASCII
|
||
w += 1;
|
||
++i;
|
||
} else if ((c & 0xE0) == 0xC0 && i + 1 < s.size()) { // 2字节UTF-8
|
||
w += 2;
|
||
i += 2;
|
||
} else if ((c & 0xF0) == 0xE0 && i + 2 < s.size()) { // 3字节UTF-8，中文常见
|
||
w += 2;
|
||
i += 3;
|
||
} else if ((c & 0xF8) == 0xF0 && i + 3 < s.size()) { // 4字节UTF-8
|
||
w += 2;
|
||
i += 4;
|
||
} else {
|
||
w += 1;
|
||
++i;
|
||
}
|
||
}
|
||
return w;
|
||
}
|
||
|
||
static void appendPad(std::ostringstream& oss, const std::string& s, int targetWidth) {
|
||
oss << s;
|
||
int pad = targetWidth - getDisplayWidth(s);
|
||
if (pad < 1) pad = 1; // 至少留 1 个空格，避免粘连
|
||
oss << std::string(pad, ' ');
|
||
}
|
||
|
||
static bool startsWithStr(const std::string& s, const std::string& pre) {
|
||
return s.size() >= pre.size() && s.compare(0, pre.size(), pre) == 0;
|
||
}
|
||
|
||
// 从类似 Value_V_A_MAX_V[2-50] 中取出区间
|
||
static bool parseKeyRange(const std::string& key, int& start, int& end) {
|
||
std::smatch m;
|
||
std::regex re(R"(\[(\d+)-(\d+)\])");
|
||
if (std::regex_search(key, m, re)) {
|
||
start = std::stoi(m[1].str());
|
||
end = std::stoi(m[2].str());
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 给普通项找 meta；找不到时，再去匹配序列模板项
|
||
static std::string trimRightUnderscore(std::string s) {
|
||
while (!s.empty() && s.back() == '_') {
|
||
s.pop_back();
|
||
}
|
||
return s;
|
||
}
|
||
|
||
static std::string rawMetricNameFromKey(const std::string& key) {
|
||
return metricAfterPhase(key);
|
||
}
|
||
|
||
static std::string preferredMetaName(const std::string& rawMetric, const ParsedKey& pk) {
|
||
if (startsWithStr(rawMetric, "G_")) return pk.baseName;
|
||
return rawMetric.empty() ? pk.baseName : rawMetric;
|
||
}
|
||
|
||
static std::string secondaryMetaName(const std::string& rawMetric, const ParsedKey& pk) {
|
||
std::string preferred = preferredMetaName(rawMetric, pk);
|
||
std::string secondary = (preferred == pk.baseName) ? rawMetric : pk.baseName;
|
||
return secondary == preferred ? "" : secondary;
|
||
}
|
||
|
||
static bool isNeutralDesc(const std::string& desc) {
|
||
return desc.find("95值") == std::string::npos &&
|
||
desc.find("平均值") == std::string::npos &&
|
||
desc.find("最大值") == std::string::npos &&
|
||
desc.find("最小值") == std::string::npos;
|
||
}
|
||
|
||
static bool statMatchesMeta(const ValueMeta& vm, const ParsedKey& pk) {
|
||
return !pk.stat.empty() && vm.desc.find(pk.stat) != std::string::npos;
|
||
}
|
||
|
||
static bool daMatchesPhase(const std::string& daPath, const std::string& phase) {
|
||
bool phased = daPath.find("phs*") != std::string::npos;
|
||
if (phase == "A" || phase == "B" || phase == "C") return phased;
|
||
if (phase == "T") return !phased;
|
||
return true;
|
||
}
|
||
|
||
static bool wiringAllowed(const ValueMeta& vm, const std::string& wiring) {
|
||
if (wiring.empty() || wiring == "any") return true;
|
||
return vm.wiring == wiring || vm.wiring == "common";
|
||
}
|
||
|
||
struct MetaFilter {
|
||
std::string topic;
|
||
std::string dataType;
|
||
};
|
||
|
||
static bool metaFilterAllowed(const ValueMeta& vm, const MetaFilter& filter) {
|
||
if (!filter.topic.empty() && vm.topic != filter.topic) return false;
|
||
if (!filter.dataType.empty() && vm.dataType != filter.dataType) return false;
|
||
return true;
|
||
}
|
||
|
||
static int scoreMetaForKey(const ValueMeta& vm, const ParsedKey& pk) {
|
||
int score = 0;
|
||
if (daMatchesPhase(vm.daPath, pk.phase)) score += 20;
|
||
if (!pk.stat.empty() && vm.desc.find(pk.stat) != std::string::npos) score += 8;
|
||
if (startsWithStr(pk.stat, "95") && isNeutralDesc(vm.desc)) score += 6;
|
||
if (vm.hasOffset) score += 5;
|
||
if (pk.phase == "T" && vm.doPath.find("Tot") != std::string::npos) score += 4;
|
||
if ((pk.phase == "A" || pk.phase == "B" || pk.phase == "C") && vm.doPath.find("Tot") == std::string::npos) score += 4;
|
||
return score;
|
||
}
|
||
|
||
static const ValueMeta* bestMeta(const std::vector<const ValueMeta*>& candidates, const ParsedKey& pk) {
|
||
const ValueMeta* best = nullptr;
|
||
int bestScore = -1;
|
||
bool hasStatMatched = false;
|
||
for (const ValueMeta* vm : candidates) {
|
||
if (statMatchesMeta(*vm, pk)) {
|
||
hasStatMatched = true;
|
||
break;
|
||
}
|
||
}
|
||
for (const ValueMeta* vm : candidates) {
|
||
if (hasStatMatched && !statMatchesMeta(*vm, pk)) continue;
|
||
int score = scoreMetaForKey(*vm, pk);
|
||
if (!best || score > bestScore) {
|
||
best = vm;
|
||
bestScore = score;
|
||
}
|
||
}
|
||
return best;
|
||
}
|
||
|
||
static void collectByName(const std::unordered_map<std::string, std::vector<ValueMeta>>& metas,
|
||
const std::string& name,
|
||
const std::string& wiring,
|
||
const MetaFilter& filter,
|
||
std::vector<const ValueMeta*>& out) {
|
||
if (name.empty()) return;
|
||
auto it = metas.find(name);
|
||
if (it == metas.end()) return;
|
||
for (const auto& vm : it->second) {
|
||
if (wiringAllowed(vm, wiring) && metaFilterAllowed(vm, filter)) out.push_back(&vm);
|
||
}
|
||
}
|
||
|
||
static std::vector<const ValueMeta*> collectSequenceCandidates(
|
||
const std::unordered_map<std::string, std::vector<ValueMeta>>& metas,
|
||
const std::string& wantedName,
|
||
const ParsedKey& pk,
|
||
const std::string& wiring,
|
||
const MetaFilter& filter,
|
||
int keyStart,
|
||
int keyEnd)
|
||
{
|
||
std::vector<const ValueMeta*> out;
|
||
std::string wanted = trimRightUnderscore(wantedName);
|
||
for (const auto& kv : metas) {
|
||
for (const ValueMeta& vm : kv.second) {
|
||
if (!vm.isSequence) continue;
|
||
if (!wiringAllowed(vm, wiring)) continue;
|
||
if (!metaFilterAllowed(vm, filter)) continue;
|
||
if (vm.seqStart != keyStart || vm.seqEnd != keyEnd) continue;
|
||
|
||
std::string xmlPrefix = trimRightUnderscore(vm.seqPrefixName);
|
||
std::string xmlBase = xmlPrefix;
|
||
if (startsWithStr(xmlBase, "G_")) xmlBase = xmlBase.substr(2);
|
||
else if (startsWithStr(xmlBase, "MAX_")) xmlBase = xmlBase.substr(4);
|
||
else if (startsWithStr(xmlBase, "MIN_")) xmlBase = xmlBase.substr(4);
|
||
|
||
if (xmlPrefix == wanted || xmlBase == wanted) out.push_back(&vm);
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
static const ValueMeta* findMetaForKey(
|
||
const std::unordered_map<std::string, std::vector<ValueMeta>>& metas,
|
||
const std::string& key,
|
||
const ParsedKey& pk,
|
||
const std::string& wiring = "any",
|
||
const MetaFilter& filter = {})
|
||
{
|
||
std::string rawMetric = rawMetricNameFromKey(key);
|
||
std::string preferred = preferredMetaName(rawMetric, pk);
|
||
std::string secondary = secondaryMetaName(rawMetric, pk);
|
||
|
||
int keyStart = 0, keyEnd = 0;
|
||
if (parseKeyRange(key, keyStart, keyEnd)) {
|
||
std::string seqPreferred = rawMetric.empty() ? preferred : rawMetric;
|
||
std::string seqSecondary = (seqPreferred == preferred) ? secondary : preferred;
|
||
auto seqCandidates = collectSequenceCandidates(metas, seqPreferred, pk, wiring, filter, keyStart, keyEnd);
|
||
if (seqCandidates.empty()) seqCandidates = collectSequenceCandidates(metas, seqSecondary, pk, wiring, filter, keyStart, keyEnd);
|
||
if (!seqCandidates.empty()) return bestMeta(seqCandidates, pk);
|
||
}
|
||
|
||
std::vector<const ValueMeta*> exactCandidates;
|
||
collectByName(metas, preferred, wiring, filter, exactCandidates);
|
||
if (exactCandidates.empty()) collectByName(metas, secondary, wiring, filter, exactCandidates);
|
||
return bestMeta(exactCandidates, pk);
|
||
}
|
||
static bool parseDaValueOffset(const std::string& daPath, int& offset) {
|
||
std::smatch m;
|
||
std::regex re(R"(%(-?\d+))");
|
||
if (!std::regex_search(daPath, m, re)) return false;
|
||
offset = std::stoi(m[1].str());
|
||
return true;
|
||
}
|
||
|
||
// 把 XML 中序列 DA，如 phs*Har[%-2]$mag$f，按“数组基准 + 取值偏移量”改显示成 phs*Har[0-48]$mag$f
|
||
static std::string rewriteDaRangeForDisplay(const std::string& daPath,
|
||
const ValueMeta& vm,
|
||
int keyStart,
|
||
int keyEnd) {
|
||
if (!vm.isSequence) return daPath;
|
||
|
||
(void)keyStart;
|
||
(void)keyEnd;
|
||
int valueOffset = 0;
|
||
parseDaValueOffset(daPath, valueOffset);
|
||
int dispStart = vm.seqStart + valueOffset;
|
||
int dispEnd = vm.seqEnd + valueOffset;
|
||
|
||
std::smatch m;
|
||
std::regex re(R"(\[%(-?\d+)\])");
|
||
if (std::regex_search(daPath, m, re)) {
|
||
std::ostringstream oss;
|
||
oss << "[" << dispStart << "-" << dispEnd << "]";
|
||
return std::regex_replace(daPath, re, oss.str(), std::regex_constants::format_first_only);
|
||
}
|
||
|
||
return daPath;
|
||
}
|
||
|
||
// 在当前目录找一个后缀文件（找不到就抛）
|
||
static fs::path findFirstByExt(const std::string& ext) {
|
||
for (auto& e : fs::directory_iterator(fs::current_path())) {
|
||
if (!e.is_regular_file()) continue;
|
||
if (e.path().extension() == ext) return e.path();
|
||
}
|
||
throw std::runtime_error("No file found with extension: " + ext + " in current folder");
|
||
}
|
||
|
||
static fs::path findFirstInputTxt() {
|
||
for (auto& e : fs::directory_iterator(fs::current_path())) {
|
||
if (!e.is_regular_file()) continue;
|
||
if (e.path().extension() != ".txt") continue;
|
||
|
||
std::string name = e.path().filename().string();
|
||
if (name == "final_sorted.txt") continue; // 跳过输出文件
|
||
|
||
return e.path();
|
||
}
|
||
throw std::runtime_error("No input .txt found in current folder");
|
||
}
|
||
|
||
struct HeaderItem {
|
||
std::string key;
|
||
std::string val;
|
||
};
|
||
|
||
static bool isHeaderKey(const std::string& key) {
|
||
return key == "DATA_TYPE" ||
|
||
key == "Monitor" ||
|
||
key == "Value_FLAG" ||
|
||
key == "Value_TIME" ||
|
||
key == "Value_interval";
|
||
}
|
||
|
||
// 【新增】相别排序：A相 -> B相 -> C相 -> T相
|
||
static int phaseOrderOf(const std::string& phase)
|
||
{
|
||
if (phase == "A") return 1;
|
||
if (phase == "B") return 2;
|
||
if (phase == "C") return 3;
|
||
if (phase == "T") return 0;
|
||
return 99;
|
||
}
|
||
|
||
struct OutItem {
|
||
std::string stat;
|
||
std::string category;
|
||
int phaseOrder; // 【新增】A/B/C/T 排序
|
||
std::string attrSort;
|
||
std::string phase;
|
||
std::string line;
|
||
std::string label;
|
||
std::string arrayBase;
|
||
std::string valueOffset;
|
||
std::string finalOffset;
|
||
std::string configText;
|
||
std::string finalText;
|
||
std::string doPath;
|
||
std::string daPath;
|
||
std::string wiring = "common"; // star/delta/common
|
||
bool hasOffset = false;
|
||
int offset = 0;
|
||
};
|
||
|
||
struct SheetSpec {
|
||
std::string name;
|
||
std::string topic;
|
||
std::string dataType;
|
||
std::string wiring;
|
||
bool showStatBlocks = false;
|
||
std::string frontType;
|
||
};
|
||
|
||
struct SheetStats {
|
||
std::string sheetName;
|
||
int normal = 0;
|
||
int abnormal = 0;
|
||
int missing = 0;
|
||
};
|
||
|
||
struct OriginRecord {
|
||
std::string path;
|
||
std::string value;
|
||
std::string reportName;
|
||
int sourceOrder = 0;
|
||
};
|
||
|
||
struct OriginHeader {
|
||
std::string title;
|
||
std::string fileName;
|
||
int sourceOrder = 0;
|
||
std::vector<HeaderItem> fields;
|
||
};
|
||
|
||
struct OriginData {
|
||
std::vector<OriginRecord> records;
|
||
std::vector<OriginHeader> headers;
|
||
std::unordered_map<std::string, std::vector<size_t>> pathToRecords;
|
||
std::unordered_set<size_t> used;
|
||
};
|
||
|
||
struct OriginMatch {
|
||
std::string path;
|
||
std::string value;
|
||
std::string reportName;
|
||
int sourceOrder = -1;
|
||
int rangeStart = std::numeric_limits<int>::min();
|
||
int rangeEnd = std::numeric_limits<int>::min();
|
||
std::vector<int> valueIndexes;
|
||
};
|
||
|
||
struct ComparePlan {
|
||
int originPickStart = std::numeric_limits<int>::min();
|
||
int originPickEnd = std::numeric_limits<int>::min();
|
||
};
|
||
|
||
struct JsonDataBucket {
|
||
std::vector<HeaderItem> headers;
|
||
std::unordered_map<std::string, std::string> valueByKey;
|
||
bool hasData = false;
|
||
};
|
||
|
||
struct WorkbookContext {
|
||
fs::path xmlPath;
|
||
std::unordered_map<std::string, std::vector<ValueMeta>> valueMetas;
|
||
std::unordered_set<std::string> xmlNames;
|
||
std::unordered_map<std::string, JsonDataBucket> dataByType;
|
||
OriginData originData;
|
||
bool hasOrigin = false;
|
||
std::string frontType;
|
||
};
|
||
|
||
static std::string jsonScalarForOutput(const json& v) {
|
||
if (v.is_string()) return v.get<std::string>();
|
||
return v.dump();
|
||
}
|
||
|
||
static std::string reportNameFromRoot(const json& root, const fs::path& originPath, int sourceOrder) {
|
||
if (root.is_object() && root.contains("rpt_id")) return jsonScalarForOutput(root["rpt_id"]);
|
||
if (root.is_object() && root.contains("rpt_name")) return jsonScalarForOutput(root["rpt_name"]);
|
||
if (root.is_object() && root.contains("report_name")) return jsonScalarForOutput(root["report_name"]);
|
||
if (root.is_object() && root.contains("rpt_no")) return "rpt_no=" + jsonScalarForOutput(root["rpt_no"]);
|
||
return originPath.filename().u8string();
|
||
}
|
||
|
||
static const std::vector<std::string>& originHeaderKeys() {
|
||
static const std::vector<std::string> keys = {
|
||
"rpt_no",
|
||
"data_time",
|
||
"mp_id",
|
||
"rpt_id",
|
||
"voltage_level",
|
||
"v_wiring_type"
|
||
};
|
||
return keys;
|
||
}
|
||
|
||
static const std::vector<std::string>& originHeaderDisplayKeys() {
|
||
static const std::vector<std::string> keys = {
|
||
"rpt_no",
|
||
"data_time",
|
||
"mp_id",
|
||
"voltage_level",
|
||
"v_wiring_type"
|
||
};
|
||
return keys;
|
||
}
|
||
|
||
static std::string rootHeaderValue(const json& root, const std::string& key) {
|
||
if (!root.is_object()) return "";
|
||
auto it = root.find(key);
|
||
if (it == root.end()) return "";
|
||
return jsonScalarForOutput(*it);
|
||
}
|
||
|
||
static void appendOriginHeader(OriginData& data,
|
||
const fs::path& originPath,
|
||
int sourceOrder,
|
||
const json& root,
|
||
const std::string& reportName) {
|
||
OriginHeader header;
|
||
header.title = reportName.empty() ? originPath.filename().u8string() : reportName;
|
||
header.fileName = originPath.filename().u8string();
|
||
header.sourceOrder = sourceOrder;
|
||
for (const auto& key : originHeaderKeys()) {
|
||
header.fields.push_back({key, rootHeaderValue(root, key)});
|
||
}
|
||
data.headers.push_back(std::move(header));
|
||
}
|
||
|
||
static std::vector<json> parseJsonRoots(const std::string& text) {
|
||
std::vector<json> roots;
|
||
size_t pos = 0;
|
||
while (pos < text.size()) {
|
||
while (pos < text.size() && std::isspace(static_cast<unsigned char>(text[pos]))) ++pos;
|
||
if (pos >= text.size()) break;
|
||
|
||
char open = text[pos];
|
||
if (open != '{' && open != '[') {
|
||
throw std::runtime_error("origin file contains unexpected content outside JSON object");
|
||
}
|
||
|
||
bool inString = false;
|
||
bool escape = false;
|
||
int depth = 0;
|
||
size_t end = pos;
|
||
for (; end < text.size(); ++end) {
|
||
char c = text[end];
|
||
if (inString) {
|
||
if (escape) escape = false;
|
||
else if (c == '\\') escape = true;
|
||
else if (c == '"') inString = false;
|
||
continue;
|
||
}
|
||
if (c == '"') {
|
||
inString = true;
|
||
} else if (c == '{' || c == '[') {
|
||
++depth;
|
||
} else if (c == '}' || c == ']') {
|
||
--depth;
|
||
if (depth == 0) {
|
||
++end;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (depth != 0) throw std::runtime_error("origin file contains incomplete JSON object");
|
||
roots.push_back(json::parse(text.substr(pos, end - pos)));
|
||
pos = end;
|
||
}
|
||
return roots;
|
||
}
|
||
|
||
static void appendOriginRoot(OriginData& data, const fs::path& originPath, int sourceOrder, const json& root) {
|
||
std::string reportName = reportNameFromRoot(root, originPath, sourceOrder);
|
||
appendOriginHeader(data, originPath, sourceOrder, root, reportName);
|
||
|
||
const json* mms = &root;
|
||
if (root.is_object() && root.contains("mms_json") && root["mms_json"].is_object()) {
|
||
mms = &root["mms_json"];
|
||
}
|
||
|
||
if (!mms->is_object()) {
|
||
throw std::runtime_error("origin file does not contain an object mms_json: " + originPath.string());
|
||
}
|
||
|
||
for (auto it = mms->begin(); it != mms->end(); ++it) {
|
||
OriginRecord rec;
|
||
rec.path = it.key();
|
||
rec.value = jsonScalarForOutput(it.value());
|
||
rec.reportName = reportName;
|
||
rec.sourceOrder = sourceOrder;
|
||
size_t idx = data.records.size();
|
||
data.records.push_back(rec);
|
||
data.pathToRecords[rec.path].push_back(idx);
|
||
}
|
||
}
|
||
|
||
static void appendOriginData(OriginData& data, const fs::path& originPath, int sourceOrder) {
|
||
std::string raw = ltrimBOM(readAll(originPath));
|
||
for (const auto& root : parseJsonRoots(raw)) {
|
||
appendOriginRoot(data, originPath, sourceOrder, root);
|
||
}
|
||
}
|
||
|
||
static OriginData loadOriginData(const std::vector<fs::path>& originPaths) {
|
||
OriginData data;
|
||
for (size_t i = 0; i < originPaths.size(); ++i) {
|
||
appendOriginData(data, originPaths[i], static_cast<int>(i));
|
||
}
|
||
return data;
|
||
}
|
||
|
||
static OriginData loadOriginData(const fs::path& originPath) {
|
||
std::vector<fs::path> paths{originPath};
|
||
return loadOriginData(paths);
|
||
}
|
||
|
||
static const OriginRecord* firstUnusedRecord(OriginData* origin, const std::string& path) {
|
||
if (!origin) return nullptr;
|
||
auto it = origin->pathToRecords.find(path);
|
||
if (it == origin->pathToRecords.end()) return nullptr;
|
||
for (size_t idx : it->second) {
|
||
if (!origin->used.count(idx)) return &origin->records[idx];
|
||
}
|
||
if (!it->second.empty()) return &origin->records[it->second.front()];
|
||
return nullptr;
|
||
}
|
||
|
||
static void markRecordUsed(OriginData* origin, const OriginRecord* rec) {
|
||
if (!origin || !rec) return;
|
||
size_t idx = static_cast<size_t>(rec - origin->records.data());
|
||
if (idx < origin->records.size()) origin->used.insert(idx);
|
||
}
|
||
static std::string statInstanceSuffix(const std::string& stat) {
|
||
if (stat == "平均值") return "1";
|
||
if (stat == "最大值") return "2";
|
||
if (stat == "最小值") return "3";
|
||
if (stat == "95值") return "4";
|
||
return "";
|
||
}
|
||
|
||
static std::string applyStatInstance(const std::string& doPath, const std::string& stat) {
|
||
std::string suffix = statInstanceSuffix(stat);
|
||
if (suffix.empty()) return doPath;
|
||
|
||
size_t dollar = doPath.find('$');
|
||
std::string head = dollar == std::string::npos ? doPath : doPath.substr(0, dollar);
|
||
std::string tail = dollar == std::string::npos ? "" : doPath.substr(dollar);
|
||
if (!head.empty() && head.back() == '0') {
|
||
head.back() = suffix[0];
|
||
return head + tail;
|
||
}
|
||
return doPath;
|
||
}
|
||
|
||
static std::string phaseTokenForDa(const std::string& phase, const std::string& wiring) {
|
||
if (wiring == "delta") {
|
||
if (phase == "A") return "phsAB";
|
||
if (phase == "B") return "phsBC";
|
||
if (phase == "C") return "phsCA";
|
||
}
|
||
if (phase == "A") return "phsA";
|
||
if (phase == "B") return "phsB";
|
||
if (phase == "C") return "phsC";
|
||
return "phs";
|
||
}
|
||
|
||
static std::string concreteDaPath(std::string daPath, const std::string& phase, const std::string& wiring) {
|
||
size_t pos = 0;
|
||
const std::string from = "phs*";
|
||
const std::string to = phaseTokenForDa(phase, wiring);
|
||
while ((pos = daPath.find(from, pos)) != std::string::npos) {
|
||
daPath.replace(pos, from.size(), to);
|
||
pos += to.size();
|
||
}
|
||
return daPath;
|
||
}
|
||
|
||
static std::string makeOriginPath(const std::string& doPath,
|
||
const std::string& daPath,
|
||
const std::string& stat,
|
||
const std::string& phase,
|
||
const std::string& wiring) {
|
||
if (doPath.empty() || daPath.empty()) return "";
|
||
return doPath + "$" + concreteDaPath(daPath, phase, wiring);
|
||
}
|
||
|
||
static std::vector<std::string> makeOriginPathCandidates(const std::string& doPath,
|
||
const std::string& daPath,
|
||
const std::string& stat,
|
||
const std::string& phase,
|
||
const std::string& wiring) {
|
||
std::vector<std::string> paths;
|
||
std::string primary = makeOriginPath(doPath, daPath, stat, phase, wiring);
|
||
if (!primary.empty()) paths.push_back(primary);
|
||
return paths;
|
||
}
|
||
|
||
static bool parseOriginRangePath(const std::string& path,
|
||
std::string& before,
|
||
int& start,
|
||
int& end,
|
||
std::string& after) {
|
||
std::smatch m;
|
||
static const std::regex re(R"(^(.+)\[(\d+)-(\d+)\](.*)$)");
|
||
if (!std::regex_match(path, m, re)) return false;
|
||
before = m[1].str();
|
||
start = std::stoi(m[2].str());
|
||
end = std::stoi(m[3].str());
|
||
after = m[4].str();
|
||
return start <= end;
|
||
}
|
||
|
||
static bool parseOriginIndexedPath(const std::string& path,
|
||
const std::string& before,
|
||
const std::string& after,
|
||
int& index) {
|
||
if (path.size() < before.size() + after.size() + 3) return false;
|
||
if (path.compare(0, before.size(), before) != 0) return false;
|
||
if (!after.empty() &&
|
||
path.compare(path.size() - after.size(), after.size(), after) != 0) {
|
||
return false;
|
||
}
|
||
|
||
size_t midStart = before.size();
|
||
size_t midEnd = after.empty() ? path.size() : path.size() - after.size();
|
||
if (midEnd <= midStart + 2 || path[midStart] != '[' || path[midEnd - 1] != ']') return false;
|
||
std::string number = path.substr(midStart + 1, midEnd - midStart - 2);
|
||
if (number.empty() || !std::all_of(number.begin(), number.end(), [](unsigned char ch) {
|
||
return std::isdigit(ch) != 0;
|
||
})) {
|
||
return false;
|
||
}
|
||
index = std::stoi(number);
|
||
return true;
|
||
}
|
||
|
||
static OriginMatch matchOrigin(OriginData* origin,
|
||
const std::string& doPath,
|
||
const std::string& daPath,
|
||
const std::string& stat,
|
||
const std::string& phase,
|
||
const std::string& wiring,
|
||
int pickStartOverride = std::numeric_limits<int>::min(),
|
||
int pickEndOverride = std::numeric_limits<int>::min()) {
|
||
OriginMatch match;
|
||
if (!origin) return match;
|
||
|
||
for (const std::string& path : makeOriginPathCandidates(doPath, daPath, stat, phase, wiring)) {
|
||
if (path.empty()) continue;
|
||
|
||
std::string before, after;
|
||
int start = 0, end = 0;
|
||
if (parseOriginRangePath(path, before, start, end, after)) {
|
||
int pickStart = pickStartOverride == std::numeric_limits<int>::min() ? start : pickStartOverride;
|
||
int pickEnd = pickEndOverride == std::numeric_limits<int>::min() ? end : pickEndOverride;
|
||
|
||
struct IndexedRecord {
|
||
int index = 0;
|
||
size_t recordIndex = 0;
|
||
};
|
||
std::map<int, std::vector<IndexedRecord>> bySource;
|
||
for (size_t recIndex = 0; recIndex < origin->records.size(); ++recIndex) {
|
||
int indexedPath = 0;
|
||
if (!parseOriginIndexedPath(origin->records[recIndex].path, before, after, indexedPath)) continue;
|
||
bySource[origin->records[recIndex].sourceOrder].push_back({indexedPath, recIndex});
|
||
}
|
||
|
||
int bestSource = -1;
|
||
int bestIntersection = 0;
|
||
bool bestHasPickStart = false;
|
||
for (const auto& kv : bySource) {
|
||
int intersection = 0;
|
||
bool hasPickStart = false;
|
||
for (const auto& rec : kv.second) {
|
||
if (rec.index >= pickStart && rec.index <= pickEnd) ++intersection;
|
||
if (rec.index == pickStart) hasPickStart = true;
|
||
}
|
||
if (intersection <= 0) continue;
|
||
if (bestSource < 0 ||
|
||
(hasPickStart && !bestHasPickStart) ||
|
||
(hasPickStart == bestHasPickStart && intersection > bestIntersection)) {
|
||
bestSource = kv.first;
|
||
bestIntersection = intersection;
|
||
bestHasPickStart = hasPickStart;
|
||
}
|
||
}
|
||
|
||
if (bestSource >= 0) {
|
||
std::map<int, size_t> indexToRecord;
|
||
int displayStart = std::numeric_limits<int>::max();
|
||
int displayEnd = std::numeric_limits<int>::min();
|
||
for (const auto& rec : bySource[bestSource]) {
|
||
if (indexToRecord.count(rec.index)) continue;
|
||
indexToRecord[rec.index] = rec.recordIndex;
|
||
displayStart = std::min(displayStart, rec.index);
|
||
displayEnd = std::max(displayEnd, rec.index);
|
||
}
|
||
|
||
std::ostringstream values;
|
||
bool any = false;
|
||
std::string reportName;
|
||
for (int i = displayStart; i <= displayEnd; ++i) {
|
||
if (i != displayStart) values << ",";
|
||
match.valueIndexes.push_back(i);
|
||
auto it = indexToRecord.find(i);
|
||
if (it == indexToRecord.end()) continue;
|
||
const OriginRecord& rec = origin->records[it->second];
|
||
any = true;
|
||
values << rec.value;
|
||
if (reportName.empty()) reportName = rec.reportName;
|
||
markRecordUsed(origin, &rec);
|
||
}
|
||
|
||
if (any) {
|
||
match.path = before + "[" + std::to_string(displayStart) + "-" + std::to_string(displayEnd) + "]" + after;
|
||
match.value = values.str();
|
||
match.reportName = reportName;
|
||
match.sourceOrder = bestSource;
|
||
match.rangeStart = displayStart;
|
||
match.rangeEnd = displayEnd;
|
||
return match;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
const OriginRecord* rec = firstUnusedRecord(origin, path);
|
||
if (rec) {
|
||
match.path = path;
|
||
match.value = rec->value;
|
||
match.reportName = rec->reportName;
|
||
match.sourceOrder = rec->sourceOrder;
|
||
markRecordUsed(origin, rec);
|
||
return match;
|
||
}
|
||
}
|
||
|
||
return match;
|
||
}
|
||
|
||
static size_t utf8CharLen(unsigned char c) {
|
||
if (c < 0x80) return 1;
|
||
if ((c & 0xE0) == 0xC0) return 2;
|
||
if ((c & 0xF0) == 0xE0) return 3;
|
||
if ((c & 0xF8) == 0xF0) return 4;
|
||
return 1;
|
||
}
|
||
|
||
static std::vector<std::string> wrapDisplay(const std::string& s, int width) {
|
||
std::vector<std::string> lines;
|
||
if (s.empty()) {
|
||
lines.push_back("");
|
||
return lines;
|
||
}
|
||
|
||
std::string current;
|
||
int currentWidth = 0;
|
||
for (size_t i = 0; i < s.size(); ) {
|
||
size_t len = utf8CharLen(static_cast<unsigned char>(s[i]));
|
||
if (i + len > s.size()) len = 1;
|
||
std::string ch = s.substr(i, len);
|
||
int chWidth = getDisplayWidth(ch);
|
||
|
||
if (!current.empty() && currentWidth + chWidth > width) {
|
||
lines.push_back(current);
|
||
current.clear();
|
||
currentWidth = 0;
|
||
}
|
||
|
||
current += ch;
|
||
currentWidth += chWidth;
|
||
i += len;
|
||
}
|
||
|
||
if (!current.empty()) lines.push_back(current);
|
||
return lines;
|
||
}
|
||
|
||
static std::string padCell(const std::string& s, int width) {
|
||
int pad = width - getDisplayWidth(s);
|
||
return s + std::string(pad > 0 ? pad : 0, ' ');
|
||
}
|
||
|
||
static std::string arrayBaseForMeta(const ValueMeta* vm);
|
||
static std::string valueOffsetForDa(const std::string& daPath);
|
||
static std::string finalOffsetForMeta(const ValueMeta* vm);
|
||
|
||
static std::string makeCompareLine(const OutItem& item, OriginData* origin) {
|
||
OriginMatch om = matchOrigin(origin, item.doPath, item.daPath, item.stat, item.phase, item.wiring);
|
||
|
||
const int NAME_W = 30;
|
||
const int CONFIG_W = 62;
|
||
const int PATH_W = 50;
|
||
const int FINAL_W = 70;
|
||
const int ORIGIN_W = 70;
|
||
|
||
std::vector<std::string> nameLines = wrapDisplay(item.label, NAME_W);
|
||
std::vector<std::string> configLines = wrapDisplay(item.configText, CONFIG_W);
|
||
std::vector<std::string> pathLines = wrapDisplay(om.path.empty() ? "" : ("\"" + om.path + "\""), PATH_W);
|
||
std::vector<std::string> finalLines = wrapDisplay(item.finalText, FINAL_W);
|
||
std::vector<std::string> originLines = wrapDisplay(om.value, ORIGIN_W);
|
||
|
||
size_t rows = std::max({nameLines.size(), configLines.size(), pathLines.size(), finalLines.size(), originLines.size()});
|
||
std::ostringstream oss;
|
||
for (size_t i = 0; i < rows; ++i) {
|
||
if (i) oss << "\n";
|
||
oss << "| " << padCell(i < nameLines.size() ? nameLines[i] : "", NAME_W)
|
||
<< " | " << padCell(i < configLines.size() ? configLines[i] : "", CONFIG_W)
|
||
<< " | " << padCell(i < pathLines.size() ? pathLines[i] : "", PATH_W)
|
||
<< " | " << padCell(i < finalLines.size() ? finalLines[i] : "", FINAL_W)
|
||
<< " | " << padCell(i < originLines.size() ? originLines[i] : "", ORIGIN_W)
|
||
<< " |";
|
||
}
|
||
return oss.str();
|
||
}
|
||
|
||
static bool makeOutItemForWiring(const std::unordered_map<std::string, std::vector<ValueMeta>>& valueMetas,
|
||
const std::string& key,
|
||
const std::string& val,
|
||
const ParsedKey& pk,
|
||
const std::string& category,
|
||
const std::string& wiring,
|
||
const MetaFilter& filter,
|
||
bool requireMeta,
|
||
OutItem& out) {
|
||
const ValueMeta* vm = findMetaForKey(valueMetas, key, pk, wiring, filter);
|
||
if (requireMeta && !vm) return false;
|
||
|
||
std::string desc = vm ? vm->desc : "";
|
||
std::string descClean = cleanDescSuffix(desc);
|
||
std::string attrSort = !descClean.empty() ? descClean : pk.baseName;
|
||
std::string label = (attrSort.empty() ? pk.baseName : attrSort) + pk.stat;
|
||
|
||
std::string doDisp = vm ? vm->doPath : "";
|
||
std::string daDisp = vm ? vm->daPath : "";
|
||
|
||
int keyStart = 0, keyEnd = 0;
|
||
if (vm && vm->isSequence && parseKeyRange(key, keyStart, keyEnd)) {
|
||
daDisp = rewriteDaRangeForDisplay(daDisp, *vm, keyStart, keyEnd);
|
||
}
|
||
|
||
std::ostringstream oss;
|
||
const int DO_W = 32;
|
||
const int DA_W = 38;
|
||
const int DESC_W = 42;
|
||
|
||
std::string doStr = "DO=\"" + doDisp + "\"";
|
||
std::string daStr = "DA=\"" + daDisp + "\"";
|
||
|
||
std::string showKey = key;
|
||
if (showKey.compare(0, 6, "Value_") == 0) showKey.erase(0, 6);
|
||
|
||
appendPad(oss, doStr, DO_W);
|
||
appendPad(oss, daStr, DA_W);
|
||
appendPad(oss, label, DESC_W);
|
||
|
||
std::string finalText = showKey + " = " + val;
|
||
oss << finalText;
|
||
|
||
out = {
|
||
pk.stat,
|
||
category,
|
||
phaseOrderOf(pk.phase),
|
||
attrSort,
|
||
pk.phase,
|
||
oss.str(),
|
||
label,
|
||
arrayBaseForMeta(vm),
|
||
valueOffsetForDa(vm ? vm->daPath : ""),
|
||
finalOffsetForMeta(vm),
|
||
doStr + " " + daStr,
|
||
finalText,
|
||
doDisp,
|
||
daDisp,
|
||
wiring,
|
||
vm && vm->hasOffset,
|
||
vm ? vm->offset : 0
|
||
};
|
||
return true;
|
||
}
|
||
|
||
static std::string replaceKeyRange(const std::string& key, int start, int end);
|
||
|
||
static std::string arrayBaseForMeta(const ValueMeta* vm) {
|
||
if (!vm || !vm->isSequence) return "0";
|
||
return std::to_string(vm->seqStart) + "-->" + std::to_string(vm->seqEnd);
|
||
}
|
||
|
||
static std::string valueOffsetForDa(const std::string& daPath) {
|
||
std::smatch m;
|
||
static const std::regex re(R"(%(-?\d+))");
|
||
if (!std::regex_search(daPath, m, re)) return "0";
|
||
return std::to_string(std::stoi(m[1].str()));
|
||
}
|
||
|
||
static std::string finalOffsetForMeta(const ValueMeta* vm) {
|
||
if (!vm || !vm->hasOffset) return "0";
|
||
return std::to_string(vm->offset);
|
||
}
|
||
|
||
static std::string metaNameToKeyName(const ValueMeta& vm) {
|
||
std::smatch m;
|
||
static const std::regex re(R"(^(.*)%(\d+),(\d+)%$)");
|
||
if (std::regex_match(vm.name, m, re)) {
|
||
std::string prefix = m[1].str();
|
||
if (!prefix.empty() && prefix.back() == '_') prefix.pop_back();
|
||
return prefix + "[" + m[2].str() + "-" + m[3].str() + "]";
|
||
}
|
||
return vm.name;
|
||
}
|
||
|
||
static std::string dataKeyForMeta(const ValueMeta& vm, const std::string& phase) {
|
||
std::string key = "Value_" + vm.itemName;
|
||
if (!phase.empty()) key += "_" + phase;
|
||
key += "_" + metaNameToKeyName(vm);
|
||
return key;
|
||
}
|
||
|
||
static std::string lookupNameForMeta(const ValueMeta& vm) {
|
||
std::string name = metaNameToKeyName(vm);
|
||
if (!vm.hasOffset) return name;
|
||
int start = 0, end = 0;
|
||
if (!parseKeyRange(name, start, end)) return name;
|
||
return replaceKeyRange(name, start + vm.offset, end + vm.offset);
|
||
}
|
||
|
||
static std::string lookupDataKeyForMeta(const ValueMeta& vm, const std::string& phase) {
|
||
std::string key = "Value_" + vm.itemName;
|
||
if (!phase.empty()) key += "_" + phase;
|
||
key += "_" + lookupNameForMeta(vm);
|
||
return key;
|
||
}
|
||
|
||
static std::string displayKeyForMeta(const ValueMeta& vm, const std::string& phase) {
|
||
std::string key = vm.itemName;
|
||
if (!phase.empty()) key += "_" + phase;
|
||
key += "_" + metaNameToKeyName(vm);
|
||
return key;
|
||
}
|
||
|
||
static std::vector<std::string> phasesForMeta(const ValueMeta& vm, const std::string& sheetWiring) {
|
||
if (vm.seqValue == "8") return {"T"};
|
||
if (vm.wiring == "star" || vm.wiring == "delta") return {"A", "B", "C"};
|
||
if (sheetWiring == "star" || sheetWiring == "delta") return {"A", "B", "C"};
|
||
return {""};
|
||
}
|
||
|
||
static std::string categoryForKeyAndItem(const std::string& key, const std::string& itemName) {
|
||
if (itemName == "V" || itemName == "I" || itemName == "PQ" || itemName == "F_S" || itemName == "F_L") return itemName;
|
||
if (key.find("_V_") != std::string::npos) return "V";
|
||
if (key.find("_I_") != std::string::npos) return "I";
|
||
if (key.find("PQ_") != std::string::npos || key.find("_PQ_") != std::string::npos) return "PQ";
|
||
return itemName.empty() ? "Z" : itemName;
|
||
}
|
||
|
||
static OutItem makeOutItemFromMeta(const ValueMeta& vm,
|
||
const std::string& phase,
|
||
const std::string& sheetWiring,
|
||
const std::unordered_map<std::string, std::string>& valueByKey) {
|
||
std::string dataKey = dataKeyForMeta(vm, phase);
|
||
auto it = valueByKey.find(lookupDataKeyForMeta(vm, phase));
|
||
std::string val = it == valueByKey.end() ? "" : it->second;
|
||
|
||
ParsedKey pk = parseForSort(dataKey);
|
||
if (pk.phase.empty()) pk.phase = phase;
|
||
|
||
std::string descClean = cleanDescSuffix(vm.desc);
|
||
std::string attrSort = !descClean.empty() ? descClean : metaNameToKeyName(vm);
|
||
std::string label = vm.desc.empty() ? (attrSort + pk.stat) : vm.desc;
|
||
if (vm.topic == "RTDATA" || vm.dataType == "02" || vm.dataType == "03") {
|
||
label = vm.desc.empty() ? attrSort : vm.desc;
|
||
}
|
||
|
||
std::string daDisp = vm.daPath;
|
||
int keyStart = 0, keyEnd = 0;
|
||
if (vm.isSequence && parseKeyRange(dataKey, keyStart, keyEnd)) {
|
||
daDisp = rewriteDaRangeForDisplay(daDisp, vm, keyStart, keyEnd);
|
||
}
|
||
|
||
std::string doStr = "DO=\"" + vm.doPath + "\"";
|
||
std::string daStr = "DA=\"" + daDisp + "\"";
|
||
std::string displayKey = displayKeyForMeta(vm, phase);
|
||
std::string finalText = displayKey + " = " + val;
|
||
std::string category = categoryForKeyAndItem(dataKey, vm.itemName);
|
||
|
||
return {
|
||
pk.stat,
|
||
category,
|
||
phaseOrderOf(pk.phase),
|
||
attrSort,
|
||
pk.phase,
|
||
"",
|
||
label,
|
||
arrayBaseForMeta(&vm),
|
||
valueOffsetForDa(vm.daPath),
|
||
finalOffsetForMeta(&vm),
|
||
doStr + " " + daStr,
|
||
finalText,
|
||
vm.doPath,
|
||
daDisp,
|
||
sheetWiring,
|
||
vm.hasOffset,
|
||
vm.offset
|
||
};
|
||
}
|
||
|
||
static bool alreadyAddedMetaRow(std::unordered_set<std::string>& seen,
|
||
const ValueMeta& vm,
|
||
const std::string& phase,
|
||
const std::string& sheetWiring) {
|
||
std::string key = vm.topic + "|" + sheetWiring + "|" + vm.itemName + "|" +
|
||
vm.seqValue + "|" + phase + "|" + vm.name + "|" + vm.doPath + "|" + vm.daPath;
|
||
if (seen.count(key)) return true;
|
||
seen.insert(key);
|
||
return false;
|
||
}
|
||
|
||
static bool specAllowsDataType(const SheetSpec& spec, const std::string& dataType) {
|
||
std::stringstream ss(spec.dataType);
|
||
std::string part;
|
||
while (std::getline(ss, part, ',')) {
|
||
if (part == dataType) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static std::vector<OutItem> buildItemsForSheet(const std::unordered_map<std::string, std::vector<ValueMeta>>& valueMetas,
|
||
const SheetSpec& spec,
|
||
const std::unordered_map<std::string, std::string>& valueByKey) {
|
||
std::vector<OutItem> out;
|
||
std::unordered_set<std::string> seen;
|
||
for (const auto& kv : valueMetas) {
|
||
for (const ValueMeta& vm : kv.second) {
|
||
if (vm.topic != spec.topic || !specAllowsDataType(spec, vm.dataType)) continue;
|
||
if (!wiringAllowed(vm, spec.wiring)) continue;
|
||
if (vm.doPath.empty() && vm.daPath.empty()) continue;
|
||
for (const std::string& phase : phasesForMeta(vm, spec.wiring)) {
|
||
if (alreadyAddedMetaRow(seen, vm, phase, spec.wiring)) continue;
|
||
out.push_back(makeOutItemFromMeta(vm, phase, spec.wiring, valueByKey));
|
||
}
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
static std::string htmlEscape(const std::string& s) {
|
||
std::string out;
|
||
out.reserve(s.size());
|
||
for (char c : s) {
|
||
if (c == '&') out += "&";
|
||
else if (c == '<') out += "<";
|
||
else if (c == '>') out += ">";
|
||
else if (c == '"') out += """;
|
||
else out += c;
|
||
}
|
||
return out;
|
||
}
|
||
|
||
static std::vector<std::string> splitCommaValues(const std::string& s) {
|
||
std::vector<std::string> values;
|
||
std::stringstream ss(s);
|
||
std::string item;
|
||
while (std::getline(ss, item, ',')) values.push_back(item);
|
||
if (values.empty()) values.push_back("");
|
||
return values;
|
||
}
|
||
|
||
static std::string trimValue(std::string value) {
|
||
value.erase(value.begin(), std::find_if(value.begin(), value.end(), [](unsigned char ch) {
|
||
return std::isspace(ch) == 0;
|
||
}));
|
||
value.erase(std::find_if(value.rbegin(), value.rend(), [](unsigned char ch) {
|
||
return std::isspace(ch) == 0;
|
||
}).base(), value.end());
|
||
return value;
|
||
}
|
||
|
||
static std::string lowerValue(std::string value) {
|
||
std::transform(value.begin(), value.end(), value.begin(),
|
||
[](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
|
||
return value;
|
||
}
|
||
|
||
static bool parseNumberValue(const std::string& text, long double& out) {
|
||
std::string s = trimValue(text);
|
||
if (s.empty()) return false;
|
||
errno = 0;
|
||
char* end = nullptr;
|
||
const char* begin = s.c_str();
|
||
long double value = std::strtold(begin, &end);
|
||
if (begin == end) return false;
|
||
while (end && *end && std::isspace(static_cast<unsigned char>(*end))) ++end;
|
||
if (end && *end) return false;
|
||
if (errno == ERANGE) return false;
|
||
if (!std::isfinite(static_cast<double>(value))) return false;
|
||
out = value;
|
||
return true;
|
||
}
|
||
|
||
static std::string fixedSixNumber(long double value) {
|
||
std::ostringstream oss;
|
||
oss.setf(std::ios::fixed, std::ios::floatfield);
|
||
oss << std::setprecision(6) << static_cast<double>(value);
|
||
std::string out = oss.str();
|
||
if (out == "-0.000000") out = "0.000000";
|
||
return out;
|
||
}
|
||
|
||
static std::string roundOriginValueForDisplay(const std::string& value) {
|
||
long double number = 0;
|
||
if (!parseNumberValue(value, number)) return trimValue(value);
|
||
return fixedSixNumber(number);
|
||
}
|
||
|
||
static std::vector<std::string> roundOriginValuesForDisplay(const std::vector<std::string>& values) {
|
||
std::vector<std::string> out;
|
||
out.reserve(values.size());
|
||
for (const auto& value : values) out.push_back(roundOriginValueForDisplay(value));
|
||
return out;
|
||
}
|
||
|
||
static std::string compareValueKey(const std::string& value) {
|
||
std::string trimmed = trimValue(value);
|
||
long double number = 0;
|
||
if (parseNumberValue(trimmed, number)) return fixedSixNumber(number);
|
||
return lowerValue(trimmed);
|
||
}
|
||
|
||
static bool hasNullValue(const std::vector<std::string>& values) {
|
||
for (const auto& value : values) {
|
||
if (lowerValue(trimValue(value)) == "null") return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static bool valuesEqualForCompare(const std::vector<std::string>& finalValues,
|
||
const std::vector<std::string>& originValues,
|
||
int originStartIndex = 0) {
|
||
if (originStartIndex < 0) return false;
|
||
if (originValues.size() < static_cast<size_t>(originStartIndex) + finalValues.size()) return false;
|
||
for (size_t i = 0; i < finalValues.size(); ++i) {
|
||
if (compareValueKey(finalValues[i]) != compareValueKey(originValues[originStartIndex + i])) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
static int displayIndexForOriginIndex(const std::vector<int>& originIndexes, int originIndex) {
|
||
auto it = std::find(originIndexes.begin(), originIndexes.end(), originIndex);
|
||
if (it == originIndexes.end()) return -1;
|
||
return static_cast<int>(std::distance(originIndexes.begin(), it));
|
||
}
|
||
|
||
static bool valuesEqualForCompareByOriginIndex(const std::vector<std::string>& finalValues,
|
||
const std::vector<std::string>& originValues,
|
||
const std::vector<int>& originIndexes,
|
||
int originPickStart) {
|
||
if (originPickStart == std::numeric_limits<int>::min()) {
|
||
return valuesEqualForCompare(finalValues, originValues, 0);
|
||
}
|
||
if (originIndexes.empty()) {
|
||
int originStartIndex = originPickStart < 0 ? -1 : originPickStart;
|
||
return valuesEqualForCompare(finalValues, originValues, originStartIndex);
|
||
}
|
||
for (size_t i = 0; i < finalValues.size(); ++i) {
|
||
int displayIndex = displayIndexForOriginIndex(originIndexes, originPickStart + static_cast<int>(i));
|
||
if (displayIndex < 0 || displayIndex >= static_cast<int>(originValues.size())) return false;
|
||
if (compareValueKey(finalValues[i]) != compareValueKey(originValues[displayIndex])) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
static bool parseArrayBaseRange(const std::string& arrayBase, int& start, int& end) {
|
||
std::smatch m;
|
||
static const std::regex re(R"(^\s*(-?\d+)\s*-->\s*(-?\d+)\s*$)");
|
||
if (!std::regex_match(arrayBase, m, re)) return false;
|
||
start = std::stoi(m[1].str());
|
||
end = std::stoi(m[2].str());
|
||
return start <= end;
|
||
}
|
||
|
||
static int parseOffsetText(const std::string& text, int fallback = 0) {
|
||
try {
|
||
if (trimValue(text).empty()) return fallback;
|
||
return std::stoi(trimValue(text));
|
||
} catch (...) {
|
||
return fallback;
|
||
}
|
||
}
|
||
|
||
static ComparePlan comparePlanForItem(const std::string& finalKey, const OutItem& item) {
|
||
ComparePlan plan;
|
||
(void)finalKey;
|
||
int baseStart = 0;
|
||
int baseEnd = 0;
|
||
if (!parseArrayBaseRange(item.arrayBase, baseStart, baseEnd)) return plan;
|
||
int valueOffset = parseOffsetText(item.valueOffset, 0);
|
||
plan.originPickStart = baseStart + valueOffset;
|
||
plan.originPickEnd = baseEnd + valueOffset;
|
||
return plan;
|
||
}
|
||
|
||
static std::string matchStyleForValues(bool hasOriginContext,
|
||
bool hasOriginMatch,
|
||
const std::vector<std::string>& finalValues,
|
||
const std::vector<std::string>& originDisplayValues,
|
||
int originStartIndex = 0) {
|
||
if (hasNullValue(finalValues)) return "MatchRed";
|
||
if (!hasOriginContext) return "";
|
||
if (!hasOriginMatch) return "MatchRed";
|
||
return valuesEqualForCompare(finalValues, originDisplayValues, originStartIndex) ? "MatchGreen" : "MatchOrange";
|
||
}
|
||
|
||
static void addRowStats(SheetStats* stats, const std::string& rowStyle) {
|
||
if (!stats) return;
|
||
if (rowStyle == "MatchGreen") ++stats->normal;
|
||
else if (rowStyle == "MatchOrange") ++stats->abnormal;
|
||
else if (rowStyle == "MatchRed") ++stats->missing;
|
||
}
|
||
|
||
static std::string cellAttrs(const std::string& styleId, const std::string& extra = "") {
|
||
std::string attrs;
|
||
if (!styleId.empty()) attrs += " ss:StyleID=\"" + styleId + "\"";
|
||
attrs += extra;
|
||
return attrs;
|
||
}
|
||
|
||
static bool splitFinalText(const std::string& text, std::string& key, std::string& value) {
|
||
size_t pos = text.find(" = ");
|
||
if (pos == std::string::npos) {
|
||
key = text;
|
||
value.clear();
|
||
return false;
|
||
}
|
||
key = text.substr(0, pos);
|
||
value = text.substr(pos + 3);
|
||
return true;
|
||
}
|
||
|
||
static std::string replaceKeyRange(const std::string& key, int start, int end) {
|
||
std::regex re(R"(\[(\d+)-(\d+)\])");
|
||
std::ostringstream oss;
|
||
oss << "[" << start << "-" << end << "]";
|
||
return std::regex_replace(key, re, oss.str(), std::regex_constants::format_first_only);
|
||
}
|
||
|
||
static std::string offsetFinalKey(const std::string& key, const OutItem& item) {
|
||
if (!item.hasOffset) return key;
|
||
int start = 0, end = 0;
|
||
if (!parseKeyRange(key, start, end)) return key;
|
||
return replaceKeyRange(key, start + item.offset, end + item.offset);
|
||
}
|
||
|
||
static std::string originSeriesKey(const std::string& finalKey, const OutItem& item) {
|
||
int start = 0, end = 0;
|
||
if (!parseKeyRange(item.daPath, start, end)) return finalKey;
|
||
return replaceKeyRange(finalKey, start, end);
|
||
}
|
||
|
||
static std::string originSeriesKeyForMatch(const std::string& finalKey,
|
||
const OutItem& item,
|
||
const OriginMatch& match) {
|
||
if (match.rangeStart != std::numeric_limits<int>::min() &&
|
||
match.rangeEnd != std::numeric_limits<int>::min()) {
|
||
return replaceKeyRange(finalKey, match.rangeStart, match.rangeEnd);
|
||
}
|
||
return originSeriesKey(finalKey, item);
|
||
}
|
||
|
||
static void writeSsCell(std::ofstream& ofs, const std::string& value, const std::string& attrs = "") {
|
||
ofs << "<Cell" << attrs << "><Data ss:Type=\"String\">" << htmlEscape(value) << "</Data></Cell>";
|
||
}
|
||
|
||
static void writeSsRowStart(std::ofstream& ofs, int height = 0) {
|
||
if (height > 0) ofs << "<Row ss:AutoFitHeight=\"0\" ss:Height=\"" << height << "\">";
|
||
else ofs << "<Row>";
|
||
}
|
||
|
||
static std::string displayLabelForSheet(const OutItem& item) {
|
||
if (item.phase == "A" || item.phase == "B" || item.phase == "C") {
|
||
return item.phase + "相" + item.label;
|
||
}
|
||
return item.label;
|
||
}
|
||
|
||
static std::string originHeaderFieldValue(const OriginHeader& header, const std::string& key) {
|
||
for (const auto& field : header.fields) {
|
||
if (field.key == key) return field.val;
|
||
}
|
||
return "";
|
||
}
|
||
|
||
static std::vector<OriginHeader> visibleOriginHeadersForSheet(OriginData* origin,
|
||
const std::vector<OutItem>& items,
|
||
const std::string& wiring) {
|
||
std::vector<OriginHeader> visible;
|
||
if (!origin) return visible;
|
||
|
||
OriginData probe = *origin;
|
||
std::set<int> usedOrders;
|
||
for (const auto& item : items) {
|
||
if (item.wiring != wiring) continue;
|
||
OriginMatch om = matchOrigin(&probe, item.doPath, item.daPath, item.stat, item.phase, item.wiring);
|
||
if (!om.value.empty() && om.sourceOrder >= 0) usedOrders.insert(om.sourceOrder);
|
||
}
|
||
|
||
for (const auto& header : origin->headers) {
|
||
if (usedOrders.count(header.sourceOrder)) visible.push_back(header);
|
||
}
|
||
return visible;
|
||
}
|
||
|
||
static void writeDataWorksheet(std::ofstream& ofs,
|
||
const std::string& sheetName,
|
||
const std::string& wiring,
|
||
const std::vector<HeaderItem>& headers,
|
||
const std::vector<std::string>& blocks,
|
||
const std::vector<OutItem>& items,
|
||
OriginData* origin,
|
||
bool showStatBlocks,
|
||
SheetStats* stats) {
|
||
const int maxValues = 64;
|
||
std::vector<OriginHeader> visibleOriginHeaders = visibleOriginHeadersForSheet(origin, items, wiring);
|
||
const int totalCols = std::max(9 + maxValues, 3 + static_cast<int>(visibleOriginHeaders.size()));
|
||
|
||
ofs << "<Worksheet ss:Name=\"" << htmlEscape(sheetName) << "\"><Table>\n";
|
||
ofs << "<Column ss:Width=\"210\"/><Column ss:Width=\"75\"/><Column ss:Width=\"85\"/><Column ss:Width=\"85\"/>";
|
||
ofs << "<Column ss:Width=\"310\"/><Column ss:Width=\"120\"/><Column ss:Width=\"280\"/>";
|
||
ofs << "<Column ss:Width=\"55\"/><Column ss:Width=\"150\"/>";
|
||
for (int i = 0; i < maxValues; ++i) ofs << "<Column ss:Width=\"90\"/>";
|
||
ofs << "\n";
|
||
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "头部信息", " ss:StyleID=\"Section\" ss:MergeAcross=\"" + std::to_string(totalCols - 1) + "\"");
|
||
ofs << "</Row>\n";
|
||
|
||
size_t originHeaderRows = visibleOriginHeaders.empty() ? 0 : originHeaderDisplayKeys().size() + 1;
|
||
size_t headerRows = std::max(headers.size(), originHeaderRows);
|
||
for (size_t row = 0; row < headerRows; ++row) {
|
||
writeSsRowStart(ofs);
|
||
if (row < headers.size()) {
|
||
writeSsCell(ofs, headers[row].key, " ss:StyleID=\"Default\"");
|
||
writeSsCell(ofs, headers[row].val, " ss:StyleID=\"Default\"");
|
||
} else {
|
||
writeSsCell(ofs, "", " ss:StyleID=\"Default\"");
|
||
writeSsCell(ofs, "", " ss:StyleID=\"Default\"");
|
||
}
|
||
|
||
if (!visibleOriginHeaders.empty()) {
|
||
if (row == 0) {
|
||
writeSsCell(ofs, "原始报告", " ss:StyleID=\"Section\"");
|
||
for (const auto& oh : visibleOriginHeaders) {
|
||
writeSsCell(ofs, oh.fileName.empty() ? oh.title : oh.fileName, " ss:StyleID=\"Section\"");
|
||
}
|
||
} else {
|
||
size_t fieldIndex = row - 1;
|
||
const auto& displayKeys = originHeaderDisplayKeys();
|
||
std::string key = fieldIndex < displayKeys.size() ? displayKeys[fieldIndex] : "";
|
||
writeSsCell(ofs, key, " ss:StyleID=\"Default\"");
|
||
for (const auto& oh : visibleOriginHeaders) {
|
||
writeSsCell(ofs, key.empty() ? "" : originHeaderFieldValue(oh, key), " ss:StyleID=\"Default\"");
|
||
}
|
||
}
|
||
}
|
||
ofs << "</Row>\n";
|
||
}
|
||
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "名称", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "数组基准", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "取值偏移量", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "最终值偏移", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "配置项", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "报告名", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "原始路径", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "类型", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "字段", " ss:StyleID=\"Head\"");
|
||
for (int i = 1; i <= maxValues; ++i) writeSsCell(ofs, "值" + std::to_string(i), " ss:StyleID=\"Head\"");
|
||
ofs << "</Row>\n";
|
||
|
||
auto writeItems = [&](const std::string& statFilter) {
|
||
std::string lastCategory;
|
||
std::string lastPhase;
|
||
for (const auto& item : items) {
|
||
if (!statFilter.empty() && item.stat != statFilter) continue;
|
||
if (item.wiring != wiring) continue;
|
||
if (item.category != lastCategory) {
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, item.category, " ss:StyleID=\"Sub\" ss:MergeAcross=\"" + std::to_string(totalCols - 1) + "\"");
|
||
ofs << "</Row>\n";
|
||
lastCategory.clear();
|
||
lastPhase.clear();
|
||
}
|
||
if (item.phase != lastPhase) {
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, item.phase + " 相", " ss:StyleID=\"Sub\" ss:MergeAcross=\"" + std::to_string(totalCols - 1) + "\"");
|
||
ofs << "</Row>\n";
|
||
}
|
||
|
||
std::string finalKey, finalValue;
|
||
splitFinalText(item.finalText, finalKey, finalValue);
|
||
finalKey = offsetFinalKey(finalKey, item);
|
||
ComparePlan comparePlan = comparePlanForItem(finalKey, item);
|
||
OriginMatch om = matchOrigin(origin, item.doPath, item.daPath, item.stat, item.phase, item.wiring,
|
||
comparePlan.originPickStart, comparePlan.originPickEnd);
|
||
std::vector<std::string> finalValues = splitCommaValues(finalValue);
|
||
std::vector<std::string> originValuesRaw = splitCommaValues(om.value);
|
||
std::vector<std::string> originValues = roundOriginValuesForDisplay(originValuesRaw);
|
||
bool hasOriginMatch = origin && !om.value.empty();
|
||
int finalRangeStart = 0;
|
||
int finalRangeEnd = 0;
|
||
bool isSequenceRow = parseKeyRange(finalKey, finalRangeStart, finalRangeEnd);
|
||
int originStartIndex = -1;
|
||
if (comparePlan.originPickStart != std::numeric_limits<int>::min() &&
|
||
om.rangeStart != std::numeric_limits<int>::min()) {
|
||
originStartIndex = displayIndexForOriginIndex(om.valueIndexes, comparePlan.originPickStart);
|
||
}
|
||
std::string rowStyle;
|
||
if (hasNullValue(finalValues)) rowStyle = "MatchRed";
|
||
else if (!origin) rowStyle = "";
|
||
else if (!hasOriginMatch) rowStyle = "MatchRed";
|
||
else rowStyle = valuesEqualForCompareByOriginIndex(finalValues, originValues, om.valueIndexes,
|
||
comparePlan.originPickStart)
|
||
? "MatchGreen"
|
||
: "MatchOrange";
|
||
addRowStats(stats, rowStyle);
|
||
std::string originKey = originSeriesKeyForMatch(finalKey, item, om);
|
||
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, displayLabelForSheet(item), cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, item.arrayBase, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, item.valueOffset, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, item.finalOffset, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, item.configText, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, om.reportName, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, om.path.empty() ? "" : om.path, cellAttrs(rowStyle, " ss:MergeDown=\"1\""));
|
||
writeSsCell(ofs, "最终值", cellAttrs(rowStyle));
|
||
writeSsCell(ofs, finalKey, cellAttrs(rowStyle));
|
||
for (int i = 0; i < maxValues; ++i) writeSsCell(ofs, i < (int)finalValues.size() ? finalValues[i] : "", cellAttrs(rowStyle));
|
||
ofs << "</Row>\n";
|
||
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "原始值", cellAttrs(rowStyle, " ss:Index=\"8\""));
|
||
writeSsCell(ofs, om.value.empty() ? "" : originKey, cellAttrs(rowStyle));
|
||
for (int i = 0; i < maxValues; ++i) {
|
||
std::string attrs = (isSequenceRow && hasOriginMatch && i == originStartIndex)
|
||
? " ss:StyleID=\"OriginPickBlue\""
|
||
: cellAttrs(rowStyle);
|
||
writeSsCell(ofs, i < (int)originValues.size() ? originValues[i] : "", attrs);
|
||
}
|
||
ofs << "</Row>\n";
|
||
|
||
lastCategory = item.category;
|
||
lastPhase = item.phase;
|
||
}
|
||
};
|
||
|
||
if (showStatBlocks) {
|
||
for (const auto& stat : blocks) {
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, stat, " ss:StyleID=\"Section\" ss:MergeAcross=\"" + std::to_string(totalCols - 1) + "\"");
|
||
ofs << "</Row>\n";
|
||
writeItems(stat);
|
||
}
|
||
} else {
|
||
writeItems("");
|
||
}
|
||
|
||
ofs << "</Table></Worksheet>\n";
|
||
}
|
||
|
||
static void writeOriginRecordWorksheet(std::ofstream& ofs,
|
||
const OriginData& origin,
|
||
const std::string& sheetName,
|
||
bool matched,
|
||
bool roundValues) {
|
||
const int maxValues = 50;
|
||
ofs << "<Worksheet ss:Name=\"" << htmlEscape(sheetName) << "\"><Table>\n";
|
||
ofs << "<Column ss:Width=\"320\"/><Column ss:Width=\"120\"/><Column ss:Width=\"160\"/><Column ss:Width=\"220\"/>";
|
||
for (int i = 0; i < maxValues; ++i) ofs << "<Column ss:Width=\"90\"/>";
|
||
ofs << "\n";
|
||
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "原始路径", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "报告名", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "icd中代表的字段", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "原始值", " ss:StyleID=\"Head\"");
|
||
for (int i = 1; i <= maxValues; ++i) writeSsCell(ofs, "值" + std::to_string(i), " ss:StyleID=\"Head\"");
|
||
ofs << "</Row>\n";
|
||
|
||
for (size_t i = 0; i < origin.records.size(); ++i) {
|
||
bool isUsed = origin.used.count(i) != 0;
|
||
if (isUsed != matched) continue;
|
||
const auto& rec = origin.records[i];
|
||
std::vector<std::string> originValues = splitCommaValues(rec.value);
|
||
if (roundValues) originValues = roundOriginValuesForDisplay(originValues);
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, rec.path);
|
||
writeSsCell(ofs, rec.reportName);
|
||
writeSsCell(ofs, "");
|
||
writeSsCell(ofs, rec.value);
|
||
for (int j = 0; j < maxValues; ++j) writeSsCell(ofs, j < (int)originValues.size() ? originValues[j] : "");
|
||
ofs << "</Row>\n";
|
||
}
|
||
ofs << "</Table></Worksheet>\n";
|
||
}
|
||
|
||
static void writeMatchedWorksheet(std::ofstream& ofs, const OriginData& origin) {
|
||
writeOriginRecordWorksheet(ofs, origin, "已匹配的原始数据", true, true);
|
||
}
|
||
|
||
static void writeUnmatchedWorksheet(std::ofstream& ofs, const OriginData& origin) {
|
||
writeOriginRecordWorksheet(ofs, origin, "未匹配的原始数据", false, true);
|
||
}
|
||
|
||
static void writeSummaryWorksheet(std::ofstream& ofs, const std::vector<SheetStats>& stats) {
|
||
ofs << "<Worksheet ss:Name=\"统计信息\"><Table>\n";
|
||
ofs << "<Column ss:Width=\"180\"/><Column ss:Width=\"110\"/><Column ss:Width=\"110\"/><Column ss:Width=\"110\"/><Column ss:Width=\"90\"/>\n";
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "工作表", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "数据正常个数", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "数据异常个数", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "数据缺失个数", " ss:StyleID=\"Head\"");
|
||
writeSsCell(ofs, "总数", " ss:StyleID=\"Head\"");
|
||
ofs << "</Row>\n";
|
||
int totalNormal = 0;
|
||
int totalAbnormal = 0;
|
||
int totalMissing = 0;
|
||
for (const auto& item : stats) {
|
||
int total = item.normal + item.abnormal + item.missing;
|
||
totalNormal += item.normal;
|
||
totalAbnormal += item.abnormal;
|
||
totalMissing += item.missing;
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, item.sheetName);
|
||
writeSsCell(ofs, std::to_string(item.normal));
|
||
writeSsCell(ofs, std::to_string(item.abnormal));
|
||
writeSsCell(ofs, std::to_string(item.missing));
|
||
writeSsCell(ofs, std::to_string(total));
|
||
ofs << "</Row>\n";
|
||
}
|
||
writeSsRowStart(ofs);
|
||
writeSsCell(ofs, "合计", " ss:StyleID=\"Section\"");
|
||
writeSsCell(ofs, std::to_string(totalNormal), " ss:StyleID=\"Section\"");
|
||
writeSsCell(ofs, std::to_string(totalAbnormal), " ss:StyleID=\"Section\"");
|
||
writeSsCell(ofs, std::to_string(totalMissing), " ss:StyleID=\"Section\"");
|
||
writeSsCell(ofs, std::to_string(totalNormal + totalAbnormal + totalMissing), " ss:StyleID=\"Section\"");
|
||
ofs << "</Row>\n";
|
||
ofs << "</Table></Worksheet>\n";
|
||
}
|
||
|
||
static std::vector<HeaderItem> headersForSheet(const std::vector<HeaderItem>& headers, const std::string& dataType) {
|
||
std::vector<HeaderItem> out = headers;
|
||
std::string displayDataType = dataType;
|
||
std::replace(displayDataType.begin(), displayDataType.end(), ',', '/');
|
||
bool found = false;
|
||
for (auto& h : out) {
|
||
if (h.key == "DATA_TYPE") {
|
||
h.val = displayDataType;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!found) out.insert(out.begin(), {"DATA_TYPE", displayDataType});
|
||
return out;
|
||
}
|
||
|
||
static bool specAllowsFrontType(const SheetSpec& spec, const std::string& frontType) {
|
||
return frontType.empty() || spec.frontType.empty() || spec.frontType == frontType;
|
||
}
|
||
|
||
static void sortOutItems(std::vector<OutItem>& items) {
|
||
std::unordered_map<std::string, int> statRank{
|
||
{"95值", 0}, {"平均值", 1}, {"最大值", 2}, {"最小值", 3}
|
||
};
|
||
std::sort(items.begin(), items.end(), [&](const OutItem& a, const OutItem& b) {
|
||
int sa = statRank.count(a.stat) ? statRank[a.stat] : 99;
|
||
int sb = statRank.count(b.stat) ? statRank[b.stat] : 99;
|
||
if (sa != sb) return sa < sb;
|
||
|
||
static std::map<std::string,int> catRank = {
|
||
{"V", 0},
|
||
{"I", 1},
|
||
{"PQ", 2},
|
||
{"F_S", 3},
|
||
{"F_L", 4},
|
||
{"Z", 99}
|
||
};
|
||
|
||
int ca = catRank.count(a.category) ? catRank[a.category] : 90;
|
||
int cb = catRank.count(b.category) ? catRank[b.category] : 90;
|
||
if (ca != cb) return ca < cb;
|
||
if (a.phaseOrder != b.phaseOrder) return a.phaseOrder < b.phaseOrder;
|
||
if (a.attrSort != b.attrSort) return a.attrSort < b.attrSort;
|
||
return a.configText < b.configText;
|
||
});
|
||
}
|
||
|
||
static void writeExcelWorkbook(const fs::path& outPath,
|
||
const std::vector<std::string>& blocks,
|
||
const std::unordered_map<std::string, std::vector<ValueMeta>>& valueMetas,
|
||
const std::unordered_map<std::string, JsonDataBucket>& dataByType,
|
||
OriginData* origin,
|
||
const std::string& frontType) {
|
||
std::ofstream ofs(outPath, std::ios::binary);
|
||
if (!ofs) throw std::runtime_error("Failed to open output file: " + outPath.string());
|
||
|
||
ofs << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
|
||
ofs << "<?mso-application progid=\"Excel.Sheet\"?>\n";
|
||
ofs << "<Workbook xmlns=\"urn:schemas-microsoft-com:office:spreadsheet\" "
|
||
<< "xmlns:o=\"urn:schemas-microsoft-com:office:office\" "
|
||
<< "xmlns:x=\"urn:schemas-microsoft-com:office:excel\" "
|
||
<< "xmlns:ss=\"urn:schemas-microsoft-com:office:spreadsheet\">\n";
|
||
ofs << "<Styles>\n";
|
||
ofs << "<Style ss:ID=\"Default\" ss:Name=\"Normal\"><Alignment ss:Horizontal=\"Left\" ss:Vertical=\"Center\"/><Borders><Border ss:Position=\"Bottom\" ss:LineStyle=\"Continuous\" ss:Weight=\"1\"/><Border ss:Position=\"Left\" ss:LineStyle=\"Continuous\" ss:Weight=\"1\"/><Border ss:Position=\"Right\" ss:LineStyle=\"Continuous\" ss:Weight=\"1\"/><Border ss:Position=\"Top\" ss:LineStyle=\"Continuous\" ss:Weight=\"1\"/></Borders><Font ss:FontName=\"SimSun\" ss:Size=\"11\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"Head\" ss:Parent=\"Default\"><Font ss:Bold=\"1\"/><Interior ss:Color=\"#D9EAD3\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"Section\" ss:Parent=\"Default\"><Font ss:Bold=\"1\"/><Interior ss:Color=\"#E8EEF7\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"Sub\" ss:Parent=\"Default\"><Font ss:Bold=\"1\"/><Interior ss:Color=\"#F4F4F4\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"MatchGreen\" ss:Parent=\"Default\"><Interior ss:Color=\"#D9EAD3\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"MatchOrange\" ss:Parent=\"Default\"><Interior ss:Color=\"#FCE4D6\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"MatchRed\" ss:Parent=\"Default\"><Interior ss:Color=\"#F4CCCC\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "<Style ss:ID=\"OriginPickBlue\" ss:Parent=\"Default\"><Interior ss:Color=\"#CFE2F3\" ss:Pattern=\"Solid\"/></Style>\n";
|
||
ofs << "</Styles>\n";
|
||
|
||
std::vector<SheetSpec> sheets = {
|
||
{"星形接线", "HISDATA", "01", "star", true, "cfg_stat_data"},
|
||
{"角型接线", "HISDATA", "01", "delta", true, "cfg_stat_data"},
|
||
{"星型闪变02", "HISDATA", "02", "star", false, "cfg_stat_data"},
|
||
{"角形闪变02", "HISDATA", "02", "delta", false, "cfg_stat_data"},
|
||
{"星型闪变03", "HISDATA", "03", "star", false, "cfg_stat_data"},
|
||
{"角形闪变03", "HISDATA", "03", "delta", false, "cfg_stat_data"},
|
||
{"星型实时", "RTDATA", "01", "star", false, "cfg_3s_data"},
|
||
{"角形实时", "RTDATA", "01", "delta", false, "cfg_3s_data"},
|
||
{"星型实时闪变02", "RTDATA", "02", "star", false, "cfg_3s_data"},
|
||
{"角形实时闪变02", "RTDATA", "02", "delta", false, "cfg_3s_data"},
|
||
{"星型实时闪变03", "RTDATA", "03", "star", false, "cfg_3s_data"},
|
||
{"角形实时闪变03", "RTDATA", "03", "delta", false, "cfg_3s_data"}
|
||
};
|
||
|
||
const std::vector<HeaderItem> emptyHeaders;
|
||
const std::unordered_map<std::string, std::string> emptyValues;
|
||
std::vector<SheetStats> summaryStats;
|
||
for (const auto& spec : sheets) {
|
||
if (!specAllowsFrontType(spec, frontType)) continue;
|
||
auto bucketIt = dataByType.find(spec.dataType);
|
||
const std::vector<HeaderItem>& headers = bucketIt == dataByType.end() ? emptyHeaders : bucketIt->second.headers;
|
||
const std::unordered_map<std::string, std::string>& valueByKey =
|
||
bucketIt == dataByType.end() ? emptyValues : bucketIt->second.valueByKey;
|
||
std::vector<OutItem> sheetItems = buildItemsForSheet(valueMetas, spec, valueByKey);
|
||
sortOutItems(sheetItems);
|
||
SheetStats stats;
|
||
stats.sheetName = spec.name;
|
||
writeDataWorksheet(ofs, spec.name, spec.wiring, headersForSheet(headers, spec.dataType), blocks, sheetItems, origin, spec.showStatBlocks, &stats);
|
||
summaryStats.push_back(stats);
|
||
}
|
||
writeSummaryWorksheet(ofs, summaryStats);
|
||
OriginData emptyOrigin;
|
||
const OriginData& originForRawSheets = origin ? *origin : emptyOrigin;
|
||
writeMatchedWorksheet(ofs, originForRawSheets);
|
||
writeUnmatchedWorksheet(ofs, originForRawSheets);
|
||
|
||
ofs << "</Workbook>\n";
|
||
}
|
||
|
||
static const std::vector<std::string>& statBlocks() {
|
||
static const std::vector<std::string> blocks = {"95值", "平均值", "最大值", "最小值"};
|
||
return blocks;
|
||
}
|
||
|
||
static void writeWorkbookStage(WorkbookContext& ctx, const fs::path& outPath) {
|
||
if (ctx.hasOrigin) ctx.originData.used.clear();
|
||
OriginData* origin = ctx.hasOrigin ? &ctx.originData : nullptr;
|
||
writeExcelWorkbook(outPath, statBlocks(), ctx.valueMetas, ctx.dataByType, origin, ctx.frontType);
|
||
}
|
||
|
||
static WorkbookContext createWorkbookTemplateFromXml(const fs::path& xmlPath, const fs::path& outPath, const std::string& frontType = "") {
|
||
WorkbookContext ctx;
|
||
ctx.xmlPath = xmlPath;
|
||
ctx.frontType = frontType;
|
||
ctx.valueMetas = loadValueMetas(xmlPath);
|
||
ctx.xmlNames.reserve(ctx.valueMetas.size() * 2);
|
||
for (const auto& kv : ctx.valueMetas) ctx.xmlNames.insert(kv.first);
|
||
writeWorkbookStage(ctx, outPath);
|
||
return ctx;
|
||
}
|
||
|
||
static void collectDataTypedJsonRoots(const json& node, std::vector<const json*>& roots) {
|
||
if (node.is_object()) {
|
||
if (node.contains("DATA_TYPE")) {
|
||
roots.push_back(&node);
|
||
return;
|
||
}
|
||
for (auto it = node.begin(); it != node.end(); ++it) collectDataTypedJsonRoots(it.value(), roots);
|
||
} else if (node.is_array()) {
|
||
for (const auto& item : node) collectDataTypedJsonRoots(item, roots);
|
||
}
|
||
}
|
||
|
||
static std::string normalizeDataType(std::string dataType) {
|
||
dataType.erase(std::remove_if(dataType.begin(), dataType.end(),
|
||
[](unsigned char c) { return std::isspace(c) != 0; }),
|
||
dataType.end());
|
||
if (dataType.size() == 1 && std::isdigit(static_cast<unsigned char>(dataType[0]))) {
|
||
dataType = "0" + dataType;
|
||
}
|
||
return dataType.empty() ? "01" : dataType;
|
||
}
|
||
|
||
static std::string dataTypeFromMerged(const std::vector<std::pair<std::string, std::string>>& merged) {
|
||
for (const auto& kv : merged) {
|
||
if (kv.first == "DATA_TYPE") return normalizeDataType(kv.second);
|
||
}
|
||
return "01";
|
||
}
|
||
|
||
static void applyJsonDataToWorkbook(WorkbookContext& ctx, const json& data, const fs::path& outPath) {
|
||
std::vector<const json*> roots;
|
||
collectDataTypedJsonRoots(data, roots);
|
||
if (roots.empty()) roots.push_back(&data);
|
||
|
||
for (const json* root : roots) {
|
||
std::vector<std::pair<std::string, std::string>> flat;
|
||
flattenJson(*root, "", flat);
|
||
|
||
auto merged = mergeSequences(flat, ctx.xmlNames);
|
||
std::string dataType = dataTypeFromMerged(merged);
|
||
JsonDataBucket& bucket = ctx.dataByType[dataType];
|
||
if (bucket.hasData) continue;
|
||
bucket.headers.clear();
|
||
bucket.valueByKey.clear();
|
||
bucket.valueByKey.reserve(merged.size() * 2);
|
||
for (const auto& kv : merged) {
|
||
bucket.valueByKey[kv.first] = kv.second;
|
||
if (isHeaderKey(kv.first)) bucket.headers.push_back({kv.first, kv.second});
|
||
}
|
||
bucket.hasData = true;
|
||
}
|
||
|
||
writeWorkbookStage(ctx, outPath);
|
||
}
|
||
|
||
static void applyOriginJsonToWorkbook(WorkbookContext& ctx,
|
||
const json& originRoot,
|
||
const fs::path& originPath,
|
||
int sourceOrder,
|
||
const fs::path& outPath) {
|
||
appendOriginRoot(ctx.originData, originPath, sourceOrder, originRoot);
|
||
ctx.hasOrigin = true;
|
||
writeWorkbookStage(ctx, outPath);
|
||
}
|
||
|
||
static void addOriginJsonToContext(WorkbookContext& ctx,
|
||
const json& originRoot,
|
||
const fs::path& originPath,
|
||
int sourceOrder) {
|
||
appendOriginRoot(ctx.originData, originPath, sourceOrder, originRoot);
|
||
ctx.hasOrigin = true;
|
||
}
|
||
|
||
static json readJsonDataFile(const fs::path& txtPath) {
|
||
std::string raw = ltrimBOM(readAll(txtPath));
|
||
try {
|
||
return json::parse(raw);
|
||
} catch (...) {
|
||
std::vector<json> roots = parseJsonRoots(raw);
|
||
if (roots.size() == 1) return roots.front();
|
||
return roots;
|
||
}
|
||
}
|
||
|
||
static void applyOriginFileToWorkbook(WorkbookContext& ctx,
|
||
const fs::path& originPath,
|
||
int sourceOrder,
|
||
const fs::path& outPath) {
|
||
std::string raw = ltrimBOM(readAll(originPath));
|
||
for (const auto& root : parseJsonRoots(raw)) {
|
||
applyOriginJsonToWorkbook(ctx, root, originPath, sourceOrder, outPath);
|
||
}
|
||
}
|
||
|
||
static void addOriginFileToContext(WorkbookContext& ctx,
|
||
const fs::path& originPath,
|
||
int sourceOrder) {
|
||
std::string raw = ltrimBOM(readAll(originPath));
|
||
for (const auto& root : parseJsonRoots(raw)) {
|
||
addOriginJsonToContext(ctx, root, originPath, sourceOrder);
|
||
}
|
||
}
|
||
|
||
bool pqRunParser(const std::string& xmlPath,
|
||
const std::string& jsonPath,
|
||
const std::vector<std::string>& originPaths,
|
||
const std::string& outPath,
|
||
std::string* err,
|
||
const std::string& frontType) {
|
||
std::vector<std::string> jsonPaths;
|
||
if (!jsonPath.empty()) jsonPaths.push_back(jsonPath);
|
||
return pqRunParser(xmlPath, jsonPaths, originPaths, outPath, err, frontType);
|
||
}
|
||
|
||
bool pqRunParser(const std::string& xmlPath,
|
||
const std::vector<std::string>& jsonPaths,
|
||
const std::vector<std::string>& originPaths,
|
||
const std::string& outPath,
|
||
std::string* err,
|
||
const std::string& frontType) {
|
||
try {
|
||
fs::path xmlFile = fs::u8path(xmlPath);
|
||
fs::path output = outPath.empty() ? fs::path("final_sorted.xls") : fs::u8path(outPath);
|
||
|
||
WorkbookContext ctx = createWorkbookTemplateFromXml(xmlFile, output, frontType);
|
||
for (const auto& jsonPath : jsonPaths) {
|
||
if (!jsonPath.empty()) applyJsonDataToWorkbook(ctx, readJsonDataFile(fs::u8path(jsonPath)), output);
|
||
}
|
||
for (size_t i = 0; i < originPaths.size(); ++i) {
|
||
if (!originPaths[i].empty()) addOriginFileToContext(ctx, fs::u8path(originPaths[i]), static_cast<int>(i));
|
||
}
|
||
if (!originPaths.empty()) writeWorkbookStage(ctx, output);
|
||
return true;
|
||
} catch (const std::exception& ex) {
|
||
if (err) *err = ex.what();
|
||
return false;
|
||
}
|
||
}
|
||
|
||
int main(int argc, char** argv) {
|
||
try {
|
||
if (argc == 1) {
|
||
return runPqGuiApp();
|
||
}
|
||
|
||
fs::path xmlFile, txtFile;
|
||
std::vector<fs::path> originFiles;
|
||
bool hasOrigin = false;
|
||
const fs::path outPath = "final_sorted.xls";
|
||
|
||
if (argc >= 2) {
|
||
// ✅ Windows 中文路径/文件名：用 u8path 解析
|
||
xmlFile = fs::u8path(argv[1]);
|
||
if (argc >= 3) txtFile = fs::u8path(argv[2]);
|
||
if (argc >= 4) {
|
||
hasOrigin = true;
|
||
for (int i = 3; i < argc; ++i) {
|
||
originFiles.push_back(fs::u8path(argv[i]));
|
||
}
|
||
}
|
||
} else {
|
||
xmlFile = findFirstByExt(".xml");
|
||
}
|
||
|
||
std::cout << "[INFO] XML: " << xmlFile << "\n";
|
||
WorkbookContext ctx = createWorkbookTemplateFromXml(xmlFile, outPath);
|
||
std::cout << "[OK] Template generated: " << outPath << "\n";
|
||
|
||
if (txtFile.empty()) txtFile = findFirstInputTxt();
|
||
std::cout << "[INFO] TXT: " << txtFile << "\n";
|
||
applyJsonDataToWorkbook(ctx, readJsonDataFile(txtFile), outPath);
|
||
std::cout << "[OK] JSON data applied: " << outPath << "\n";
|
||
|
||
if (hasOrigin) {
|
||
std::cout << "[INFO] ORIGIN:";
|
||
for (const auto& originFile : originFiles) std::cout << " " << originFile;
|
||
std::cout << "\n";
|
||
for (size_t i = 0; i < originFiles.size(); ++i) {
|
||
addOriginFileToContext(ctx, originFiles[i], static_cast<int>(i));
|
||
std::cout << "[OK] Origin loaded: " << originFiles[i] << "\n";
|
||
}
|
||
writeWorkbookStage(ctx, outPath);
|
||
std::cout << "[OK] Origin data applied: " << outPath << "\n";
|
||
}
|
||
|
||
std::cout << "[OK] Generated: final_sorted.xls\n";
|
||
return 0;
|
||
|
||
} catch (const std::exception& ex) {
|
||
std::cerr << "[ERR] " << ex.what() << "\n";
|
||
std::cerr << "Usage:\n"
|
||
<< " pq_tool <LN_D001.xml> [data.txt] [origin1.txt origin2.txt ...]\n"
|
||
<< "Or put one .xml and one .txt in current folder and run without args.\n";
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|