首次提交

2026-06-16 11:18:22 +08:00
commit 068ef188e7
201 changed files with 57503 additions and 0 deletions
@@ -0,0 +1,419 @@
+#ifndef PSC_GLOBAL_INCLUDE_H
+#define PSC_GLOBAL_INCLUDE_H
+#include "Core/Statistics/Statistics.h"
+#include "Core/socket/ByteOrder.h"
+#include "SSR/export.h"
+#include <functional>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+class Global;
+
+class Invalid_Http_Param final : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+};
+
+[[noreturn]] inline void throw_invalid_http_param(const char* detail) {
+    throw Invalid_Http_Param(detail);
+}
+
+
+
+#define CHECK_JSON_PARAM \
+auto o_params = Psc::try_parse_json(req->body().data()); \
+if (!o_params.has_value()) { \
+throw_invalid_http_param("request body is not valid JSON"); \
+} \
+auto& params = o_params.value(); \
+auto that_json = &params;
+
+#define HTTP_REQUIRE_VALUE(NAME, EXPRESSION) \
+auto o_http_##NAME = (EXPRESSION); \
+if (!o_http_##NAME.has_value()) { \
+throw_invalid_http_param(#NAME); \
+} \
+auto NAME = std::move(o_http_##NAME).value();
+
+#define HTTP_REQUIRE_PTR(NAME, EXPRESSION) \
+auto NAME = (EXPRESSION); \
+if ((NAME) == nullptr) { \
+throw_invalid_http_param(#NAME); \
+}
+
+#define HTTP_REQUIRE_TRUE(EXPRESSION, DETAIL) \
+if (!(EXPRESSION)) { \
+throw_invalid_http_param(DETAIL); \
+}
+
+
+
+
+
+template <typename Value_Type>
+class Ordered_List {
+public:
+    void swap(size_t i, size_t j) {
+        std::lock_guard g(mtx);
+        if (i >= _list.size() || j >= _list.size()) return;
+
+        std::swap(_list[i], _list[j]);
+    }
+
+
+
+    void push_back(Value_Type value) {
+        std::lock_guard g(mtx);
+        _list.push_back(value); // 添加默认值
+    }
+
+    void insert(int i, Value_Type value) {
+        std::lock_guard g(mtx);
+        _list.insert(_list.begin() + i, value);
+    }
+
+    Value_Type get(size_t i) {
+        return _list[i];
+    }
+
+    void remove(size_t i) {
+        std::lock_guard g(mtx);
+        if (i >= _list.size()) return;
+        _list.erase(_list.begin() + i);
+    }
+    std::vector<Value_Type> list(){
+        std::lock_guard g(mtx);
+        return this->_list;
+    }
+
+    void clear() {
+        list().clear();
+    }
+protected:
+    std::mutex mtx;
+    std::vector<Value_Type> _list;
+};
+
+
+
+template <typename Key_Type, typename Value_Type>
+class Ordered_Map {
+public:
+
+    std::optional<Value_Type> get(Key_Type key) {
+        std::lock_guard g(mtx);
+        auto it = _map.find(key);
+        if (it != _map.end()) {
+            return it->second;
+        }
+        return std::nullopt;
+    }
+    bool swap(size_t i, size_t j) {
+        std::lock_guard g(mtx);
+        if (i >= _list.size() || j >= _list.size()) return false;
+
+        std::swap(_list[i], _list[j]);
+
+        // 更新 map 中的 value，假设你可以从 Value 中获取 key
+        Key_Type key_i = _list[i]->key;
+        Key_Type key_j = _list[j]->key;
+
+        _map[key_i] = _list[i];
+        _map[key_j] = _list[j];
+        return true;
+    }
+
+
+
+    void push_back(Value_Type value) {
+        std::lock_guard g(mtx);
+        _list.push_back(value); // 添加默认值
+        _map[value->key] = value;      // 插入到 map
+    }
+
+    bool insert(int i, Value_Type value) {
+        std::lock_guard g(mtx);
+        if (i < 0 || static_cast<size_t>(i) > _list.size()) return false;
+        _list.insert(_list.begin() + i, value);
+        _map[value->key] = value;
+        return true;
+    }
+
+    Value_Type get(size_t i) {
+        return _list[i];
+    }
+
+    std::optional<Value_Type> try_get(size_t i) {
+        std::lock_guard g(mtx);
+        if (i >= _list.size()) return std::nullopt;
+        return _list[i];
+    }
+
+    bool remove(size_t i) {
+        std::lock_guard g(mtx);
+        if (i >= _list.size()) return false;
+        Key_Type& key = _list[i]->key;
+        _map.erase(key);
+        _list.erase(_list.begin() + i);
+        return true;
+    }
+    std::vector<Value_Type> list(){
+        std::lock_guard g(mtx);
+        return this->_list;
+    }
+    // std::map<Key_Type, Value_Type> map(){
+    //     std::lock_guard g(mtx);
+    //     return this->_map;
+    // }
+    void clear() {
+        list().clear();
+        _map.clear();
+    }
+protected:
+    std::mutex mtx;
+    std::vector<Value_Type> _list;
+    std::map<Key_Type, Value_Type> _map;
+};
+
+class Mode_AC_Statistic_Data {
+public:
+    Psc::JSON to_json() {
+        std::lock_guard g(mtx);
+        Psc::JSON ret = Psc::JSON::object();
+        Ret_J(pre_second_num);
+        Ret_J(total_num);
+        Ret_J(length_error_num);
+        // Ret_J(speed);
+        return ret;
+    }
+    void add() {
+        std::lock_guard g(mtx);
+        add_inter();
+        // speed.update(1);
+    }
+    void add_length_error() {
+        std::lock_guard g(mtx);
+        add_inter();
+        length_error_num++;
+    }
+
+protected:
+    std::atomic<size_t> length_error_num{};
+    void add_inter() {
+        total_num++;
+        auto cur_time = std::time(nullptr);
+        if (cur_time != utc)
+        {
+            utc = cur_time;
+            pre_second_num = 0;
+        }
+        pre_second_num++;
+    }
+    std::mutex mtx;
+    size_t pre_second_num{};
+    size_t total_num{};
+    time_t utc{};
+   // Psc::Speed_Statistics speed;
+};
+
+
+class Statistic_Data {
+public:
+    time_t utc{};
+    size_t pre_second_num{};
+    size_t total_num{};
+    [[nodiscard]] Psc::JSON to_json() const {
+        Psc::JSON ret = Psc::JSON::object();
+        Ret_J(pre_second_num);
+        Ret_J(total_num);
+        return ret;
+    }
+    Statistic_Data() = default;
+};
+
+class DF_Statistic_Data {
+public:
+    time_t utc{};
+    size_t pre_second_num{};
+    size_t total_num{};
+    size_t crc_error_num{};
+    Psc::JSON to_json() {
+        Psc::JSON ret = Psc::JSON::object();
+        Ret_J(pre_second_num);
+        Ret_J(total_num);
+        Ret_J(crc_error_num);
+        // Ret_J(speed);
+
+        std::string t = "null";
+        if (total_num != 0) {
+            t = std::to_string(static_cast<double>(crc_error_num)/static_cast<double>(total_num)) + "%";
+        }
+        ret.append({"crc误码率", t});
+        for (auto& cur : statistic_map)
+        {
+            ret.append({cur.first, cur.second.to_json()});
+        }
+        return ret;
+    }
+    void add() {
+        add_inter();
+    }
+    void add_crc_error() {
+        crc_error_num++;
+    }
+    void add_sub_part(const std::string& key) {
+        add_sub_part_inter(key);
+    }
+
+    // Psc::Speed_Statistics speed;
+protected:
+    void add_inter() {
+        total_num++;
+        auto cur_time = std::time(nullptr);
+        if (cur_time != utc)
+        {
+            utc = cur_time;
+            pre_second_num = 0;
+        }
+        pre_second_num++;
+        // speed.update(1);
+    }
+
+    void add_sub_part_inter(const std::string& key) {
+        auto t = get_create_statistic_data(key);
+        t->total_num++;
+        auto cur_time = std::time(nullptr);
+        if (cur_time != t->utc)
+        {
+            t->utc = cur_time;
+            t->pre_second_num = 0;
+        }
+        t->pre_second_num++;
+    }
+    Statistic_Data* get_create_statistic_data(const std::string& key) {
+        Statistic_Data* t;
+        auto iter = statistic_map.find(key);
+        if (iter == statistic_map.end())
+        {
+            Statistic_Data cur{};
+            statistic_map.insert(std::make_pair(key, cur));
+        }
+        t = &statistic_map[key];
+        return t;
+    }
+
+    std::map<std::string, Statistic_Data> statistic_map;
+};
+
+class Mode_S_Statistic_Data {
+public:
+    // Psc::Speed_Statistics speed;
+
+    // Psc::Speed_Statistics total_speed() const {
+    //     Psc::Speed_Statistics total_speed{};
+    //     for (auto& cur : DF_Statistic_Data_map) {
+    //         total_speed += cur.second.speed;
+    //     }
+    //     return total_speed;
+    // }
+    Psc::JSON to_json() {
+        size_t total_num = get_total_num();
+        size_t crc_error_num = get_crc_error_num();
+        Psc::JSON ret = Psc::JSON::object();
+
+
+        ret.append({"每秒数量", get_total_pre_second_num()});
+
+        Ret_J(length_error_num);
+        Ret_J(total_num);
+
+        std::string t = "null";
+        if (total_num != 0) {
+            t = std::to_string(static_cast<double>(crc_error_num)/static_cast<double>(total_num)) + "%";
+        }
+        Ret_J(crc_error_num);
+        ret.append({"crc_error_rate", t});
+
+
+
+
+        Psc::JSON df_sub_type = Psc::JSON::object();
+        for (auto& cur : DF_Statistic_Data_map)
+        {
+            df_sub_type.append({Psc::to_string(cur.first) + " [" + std::to_string(static_cast<int>(cur.first)) +  "]", cur.second.to_json()});
+        }
+        Psc::JSON cpr_error_o = Psc::JSON::object();
+        for (auto& cur : cpr_error)
+        {
+            cpr_error_o.append({Psc::to_string(cur.first) + " [" + std::to_string(static_cast<int>(cur.first)) +  "]", Psc::to_string(cur.second)});
+        }
+        ret.append({"DF子类型", df_sub_type});
+        ret.append({"CPR统计信息", cpr_error_o});
+        return ret;
+    }
+
+    void add_length_error(const std::string& key) {
+        length_error_num++;
+    }
+
+    void add_cpr_error(SSR::CPR_Error_Type cet) {
+        ++cpr_error[cet];
+    }
+
+    DF_Statistic_Data* get_create_df_statistic_data(const SSR::Downlink_Format& key) {
+        DF_Statistic_Data* t;
+        auto iter = DF_Statistic_Data_map.find(key);
+        if (iter == DF_Statistic_Data_map.end())
+        {
+            DF_Statistic_Data cur{};
+            DF_Statistic_Data_map.insert(std::make_pair(key, cur));
+        }
+        t = &DF_Statistic_Data_map[key];
+        return t;
+    }
+
+    size_t get_total_pre_second_num() {
+        size_t ret = 0;
+        for (auto& cur : DF_Statistic_Data_map) {
+            ret += cur.second.pre_second_num;
+        }
+        return ret;
+    }
+
+    size_t get_total_num() {
+        size_t ret = 0;
+        for (auto& cur : DF_Statistic_Data_map) {
+            ret += cur.second.total_num;
+        }
+        return ret;
+    }
+    size_t get_crc_error_num() {
+        size_t ret = 0;
+        for (auto& cur : DF_Statistic_Data_map) {
+            ret += cur.second.crc_error_num;
+        }
+        return ret;
+    }
+
+
+protected:
+    std::atomic<size_t> length_error_num{};
+    std::map<SSR::Downlink_Format, DF_Statistic_Data> DF_Statistic_Data_map;
+    std::map<SSR::CPR_Error_Type, size_t> cpr_error;
+};
+
+
+template <typename T>
+class Immutable : public T {
+
+};
+
+#endif