335 lines
12 KiB
C++
335 lines
12 KiB
C++
#ifndef CONFIG_H_H
|
|
#define CONFIG_H_H
|
|
#include "../DSP/export.h"
|
|
#include "../Data_Feed/export.h"
|
|
#include "../Data_Source/export.h"
|
|
#include "Core/spdlog/export.h"
|
|
#include "MLAT.h"
|
|
#include "Source_Feed_Relation.h"
|
|
#include <fstream>
|
|
#include <map>
|
|
#include <vector>
|
|
inline bool delete_log = false;
|
|
extern std::string default_config_path;
|
|
std::string get_config_path();
|
|
struct Log_Config {
|
|
~Log_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Log_Config()" << std::endl;
|
|
}
|
|
enum class Open_Mode { Append, Delete, Rename };
|
|
Open_Mode open_mode = Open_Mode::Rename;
|
|
std::uint16_t piece_num{};
|
|
std::uint16_t size_MB{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Console_Config {
|
|
~Console_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Console_Config()" << std::endl;
|
|
}
|
|
bool record_playback;
|
|
bool mode_s_console;
|
|
bool post_request;
|
|
bool mlat_server;
|
|
PSC_USE_JSON
|
|
};
|
|
struct Http_Monitor_Config {
|
|
bool access_log = true;
|
|
std::size_t slow_request_threshold_ms = 1000;
|
|
std::size_t slow_scope_threshold_ms = 100;
|
|
PSC_USE_JSON
|
|
};
|
|
struct Mode_ACS_Config_Base_Data {
|
|
Psc::Copyable_Atomic<std::size_t> timeout_seconds{};
|
|
SSR::CPR::D max_speed_m_s{};
|
|
SSR::CPR::D air_pos_timeout = 8;
|
|
SSR::CPR::D surface_pos_timeout = 32;
|
|
Psc::Copyable_Atomic<std::size_t> read_milliseconds{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Mode_ACS_Config_Data {
|
|
Psc::Copyable_Atomic<bool> wait_process_msg;
|
|
Psc::Copyable_Atomic<bool> time_space_filter;
|
|
Psc::Copyable_Atomic<bool> speed_filter;
|
|
Psc::Copyable_Atomic<std::size_t> max_track_point_size{};
|
|
Psc::Copyable_Atomic<std::size_t> mode_s_max_num{};
|
|
Psc::Copyable_Atomic<std::size_t> mode_other_max_num{};
|
|
Psc::Copyable_Atomic<std::size_t> report_data_feed_msg_mum{};
|
|
Psc::Copyable_Atomic<std::size_t> default_min_aircraft_list_num{};
|
|
Psc::Copyable_Atomic<std::size_t> aircraft_change_list_min_position_points = 2;
|
|
Psc::Copyable_Atomic<bool> aircraft_change_list_adsb_range_filter = true;
|
|
Psc::Copyable_Atomic<double> aircraft_change_list_adsb_range_factor = 1.2;
|
|
Psc::Copyable_Atomic<double> adsb_theoretical_target_altitude_meters = 10000.0;
|
|
Psc::Copyable_Atomic<bool> ignore_df_11{};
|
|
Psc::Copyable_Atomic<bool> monitor_msg_live{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Mode_ACS_Config : Mode_ACS_Config_Base_Data, Mode_ACS_Config_Data {
|
|
DELETE_COPY(Mode_ACS_Config)
|
|
Data_feed_Config data_feed_config;
|
|
Data_Source_Config data_source_config;
|
|
Source_Feed_Relation_Config source_feed_relation_config;
|
|
Psc::Copyable_Atomic<std::size_t> Report_Data_Feed_Message_Num{};
|
|
Mode_ACS_Config() = default;
|
|
~Mode_ACS_Config() {
|
|
if (delete_log)
|
|
std::cout << " ~Mode_S_Config()" << std::endl;
|
|
}
|
|
Psc::JSON to_base_json() const {
|
|
return Mode_ACS_Config_Base_Data::to_base_json();
|
|
}
|
|
void init_base_json(const Psc::JSON* that_json) {
|
|
Mode_ACS_Config_Base_Data::from_base_json(that_json);
|
|
}
|
|
void init(const Psc::JSON* that_json) {
|
|
Mode_ACS_Config_Base_Data::from_base_json(that_json);
|
|
Mode_ACS_Config_Data::from_base_json(that_json);
|
|
data_feed_config.init(that_json->get("data_feed"));
|
|
data_source_config.init(that_json->get("data_source"));
|
|
source_feed_relation_config.from_json(
|
|
that_json->get("source_feed_relation"));
|
|
if (monitor_msg_live) {
|
|
SSR::Monitor_Mode_ACS_Message_Num = this->monitor_msg_live;
|
|
}
|
|
}
|
|
Psc::JSON to_base_json() {
|
|
Psc::JSON ret = Mode_ACS_Config_Base_Data::to_base_json();
|
|
ret += Mode_ACS_Config_Data::to_base_json();
|
|
ret.append(Psc::JSON("data_feed", data_feed_config.to_json()));
|
|
ret.append(Psc::JSON("data_source", data_source_config.to_json()));
|
|
ret.append(Psc::JSON("source_feed_relation",
|
|
source_feed_relation_config.to_json()));
|
|
return ret;
|
|
}
|
|
void server(Global* g);
|
|
};
|
|
struct Web_Server_Config {
|
|
[[nodiscard]] std::string get_true_webapp() const {
|
|
return Psc::get_abs_path(webapp);
|
|
}
|
|
PSC_USE_JSON
|
|
std::string webapp;
|
|
};
|
|
struct Map_Tile_Config {
|
|
std::vector<std::string> directories;
|
|
std::string path_layout;
|
|
std::string y_axis;
|
|
std::string projection;
|
|
std::string extension;
|
|
std::uint32_t tile_size{};
|
|
std::uint32_t minimum_level{};
|
|
std::uint32_t maximum_level{};
|
|
std::string encoding;
|
|
[[nodiscard]] std::vector<std::string> get_true_directories() const {
|
|
std::vector<std::string> ret;
|
|
ret.reserve(directories.size());
|
|
for (const auto& path : directories) {
|
|
ret.emplace_back(Psc::get_abs_path(path));
|
|
}
|
|
return ret;
|
|
}
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
[[nodiscard]] Psc::JSON to_public_json(std::string_view url) const;
|
|
};
|
|
struct Map_Resources_Config {
|
|
std::string current_imagery_key = "imagery";
|
|
Map_Tile_Config imagery;
|
|
Map_Tile_Config google_imagery;
|
|
Map_Tile_Config terrain;
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
[[nodiscard]] Psc::JSON to_public_json() const;
|
|
[[nodiscard]] bool is_imagery_key(std::string_view key) const;
|
|
};
|
|
struct Map_Camera_Config {
|
|
double longitude = 121.27;
|
|
double latitude = 37.41;
|
|
double height = 300000.0;
|
|
double heading = 0.0;
|
|
double pitch = -90.0;
|
|
double roll = 0.0;
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
};
|
|
struct Map_Tile_View_Config {
|
|
std::string current_imagery_key = "imagery";
|
|
std::string tile_zoom_mode = "native";
|
|
std::uint32_t tile_display_maximum_level = 19;
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
[[nodiscard]] static bool is_tile_zoom_mode(std::string_view mode);
|
|
};
|
|
struct Map_View_Config {
|
|
std::string scene_mode = "3d";
|
|
Map_Tile_View_Config map2d;
|
|
Map_Tile_View_Config map3d;
|
|
Map_Camera_Config camera;
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
[[nodiscard]] static bool is_scene_mode(std::string_view mode);
|
|
};
|
|
struct Cesium_Graphics_Config {
|
|
bool debug_show_frames_per_second = true;
|
|
std::uint32_t target_frame_rate = 30;
|
|
bool use_browser_recommended_resolution = true;
|
|
double resolution_scale = 0.7;
|
|
std::uint32_t msaa_samples = 1;
|
|
bool fxaa = false;
|
|
bool shadows = false;
|
|
bool enable_lighting = false;
|
|
bool solar_lighting = false;
|
|
double solar_light_intensity = 1.5;
|
|
std::uint32_t maximum_screen_space_error = 4;
|
|
bool terrain_enabled_in_3d = false;
|
|
double terrain_exaggeration = 1.0;
|
|
bool terrain_limit_maximum_level = true;
|
|
std::uint32_t terrain_maximum_level = 15;
|
|
std::uint32_t terrain_cache_tiles = 128;
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
};
|
|
struct Map_Model_Item_Config {
|
|
std::string url;
|
|
double built_in_size = 50.0;
|
|
double heading_offset_degrees = 0.0;
|
|
double pitch_offset_degrees = 0.0;
|
|
double roll_offset_degrees = 0.0;
|
|
Map_Model_Item_Config() = default;
|
|
explicit Map_Model_Item_Config(std::string url);
|
|
Map_Model_Item_Config(std::string url, double built_in_size, double heading, double pitch, double roll);
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
};
|
|
struct Map_Model_Config {
|
|
Map_Model_Item_Config aircraft_model{"/ui/model/aircraft.glb", 50.0, -90.0, 0.0, 0.0};
|
|
std::map<std::string, Map_Model_Item_Config> aircraft_models;
|
|
Map_Model_Item_Config base_station_model{"/ui/model/base-station.glb", 100.0, 0.0, 0.0, 0.0};
|
|
Map_Model_Config();
|
|
void from_base_json(const Psc::JSON* that_json);
|
|
[[nodiscard]] Psc::JSON to_base_json() const;
|
|
};
|
|
struct Net_Config {
|
|
std::string key{};
|
|
std::string ip{};
|
|
std::uint16_t port{};
|
|
std::string netmask{};
|
|
std::string gateway{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Device_Config {
|
|
Ordered_Map<std::string, Net_Config*> list;
|
|
~Device_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Device_Config()" << std::endl;
|
|
for (auto it : list.list()) {
|
|
delete it;
|
|
}
|
|
list.clear();
|
|
}
|
|
Psc::JSON to_base_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Psc::JSON net = Psc::JSON::array();
|
|
for (auto& li : list.list()) {
|
|
net.append(li->to_base_json());
|
|
}
|
|
ret.append({"net", net});
|
|
return ret;
|
|
}
|
|
Device_Config() = default;
|
|
void init(const Psc::JSON* that_json) {
|
|
for (auto& li : that_json->get("net")->children) {
|
|
auto cur = new Net_Config();
|
|
cur->from_base_json(&li);
|
|
list.push_back(cur);
|
|
}
|
|
}
|
|
Psc::JSON to_net_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Psc::JSON net = Psc::JSON::array();
|
|
for (auto& li : list.list()) {
|
|
net.append(li->to_base_json());
|
|
}
|
|
ret.append({"net", net});
|
|
return ret;
|
|
}
|
|
void server(Global* g);
|
|
};
|
|
class Config {
|
|
public:
|
|
Config() = default;
|
|
DELETE_COPY(Config)
|
|
MLAT_Config mlat;
|
|
Device_Config device_config;
|
|
Web_Server_Config web_server_config;
|
|
Map_Resources_Config map_resources_config;
|
|
Map_View_Config map_view_config;
|
|
Cesium_Graphics_Config cesium_graphics_config;
|
|
Map_Model_Config map_model_config;
|
|
Mode_ACS_Config mode_acs;
|
|
Log_Config log_config;
|
|
Console_Config console_config{};
|
|
DSP_Config dsp_config;
|
|
Psc::JSON drogon_config;
|
|
Http_Monitor_Config http_monitor_config;
|
|
std::string version;
|
|
External_Resources_Manager external_resources_manager;
|
|
static Psc::JSON load() {
|
|
std::string config_path = get_config_path();
|
|
std::ifstream iso(config_path);
|
|
if (!iso.is_open()) {
|
|
std::cerr << config_path << " can not open!" << std::endl;
|
|
Psc::fail_fast();
|
|
}
|
|
else {
|
|
std::cout << get_current_date_string() << " 启动加载配置文件: 【"
|
|
<< config_path << "】" << std::endl;
|
|
}
|
|
std::stringstream ss;
|
|
std::stringstream buffer;
|
|
buffer << iso.rdbuf();
|
|
std::string fileContents = buffer.str();
|
|
return Psc::parse_json(fileContents);
|
|
}
|
|
void fromJson(Psc::JSON* that_json) {
|
|
Get_J(version)
|
|
mlat.init(that_json->get("mlat"));
|
|
web_server_config.from_base_json(that_json->get("web_server"));
|
|
map_resources_config.from_base_json(that_json->get("map_resources"));
|
|
map_view_config.from_base_json(that_json->get("map_view"));
|
|
cesium_graphics_config.from_base_json(that_json->get("cesium_graphics"));
|
|
map_model_config.from_base_json(that_json->get("map_models"));
|
|
device_config.init(that_json->get("device"));
|
|
mode_acs.init(that_json->get("mode_acs"));
|
|
console_config.from_base_json(that_json->get("console"));
|
|
dsp_config.from_json(that_json->get("dsp"));
|
|
drogon_config = *that_json->get("drogon");
|
|
http_monitor_config.from_base_json(that_json->get("http_monitor"));
|
|
external_resources_manager.init(that_json->get("external_database"));
|
|
}
|
|
Psc::JSON toJson() {
|
|
auto ret = Psc::JSON::object({
|
|
{"version", version},
|
|
{"dsp", dsp_config.to_base_json()},
|
|
{"drogon", drogon_config},
|
|
{"http_monitor", http_monitor_config.to_base_json()},
|
|
{"mlat", mlat.to_base_json()},
|
|
{"web_server", web_server_config.to_base_json()},
|
|
{"map_resources", map_resources_config.to_base_json()},
|
|
{"map_view", map_view_config.to_base_json()},
|
|
{"map_models", map_model_config.to_base_json()},
|
|
{"device", device_config.to_base_json()},
|
|
{"mode_acs", mode_acs.to_base_json()},
|
|
//{"ais", ais.to_json()},
|
|
{"log", log_config.to_base_json()},
|
|
{"console", console_config.to_base_json()},
|
|
{"external_database", external_resources_manager.to_base_json()},
|
|
{"cesium_graphics", cesium_graphics_config.to_base_json()},
|
|
});
|
|
return ret;
|
|
}
|
|
static void save();
|
|
};
|
|
#endif
|