Use ArgParser API, add CsvWriter, simplify solver

Refactor CLI option handling to use the fluent lunar::ArgParser API (methods now return ArgParser& for chaining) and replace ad-hoc OptMap/apply_opt usage across many parse functions (cli and query). Added parse_one/parse_all usage and included the new header where needed. Introduced CSV helpers: csv_num and a CsvWriter class (with header checks and consistent numeric formatting) in src/common/output.hpp. Simplified root solving and removed the threaded worker machinery: eliminated RootCtx, run_wkr, and related threading/atomic includes so run_roots performs serial solves. In spc_ephem, replaced std::once_flag with a simple bool kern_loaded and removed unused mutex include. Also updated includes (added <vector>, <stdexcept> where used) and small API cleanups in include headers. Files touched include: include/lunar/arg_parser.hpp, include/lunar/rt_solver.hpp, include/lunar/spc_ephem.hpp, src/calendar.cpp, src/cli/*, src/query/*, src/common/output.hpp and others to wire the changes.

Author: lzray-universe

include/lunar/arg_parser.hpp

@@ -14,19 +14,23 @@ class ArgParser{
 	using Action=std::function<void(const std::vector<std::string>&,
 									std::size_t&,const std::string&)>;
 
-	void add(const std::string&opt,Action action){
+	ArgParser&add(const std::string&opt,Action action){
 		actions_[opt]=std::move(action);
+		return *this;
 	}
 
-	void add_flag(const std::string&opt,std::function<void()> action){
-		add(opt,[fn=std::move(action)](const std::vector<std::string>&,
-									  std::size_t&,const std::string&){ fn(); });
+	ArgParser&add_flag(const std::string&opt,std::function<void()> action){
+		return add(opt,[fn=std::move(action)](const std::vector<std::string>&,
+											 std::size_t&,const std::string&){
+			fn();
+		});
 	}
 
-	void add_value(const std::string&opt,
-				   std::function<void(const std::string&)> action){
-		add(opt,[fn=std::move(action)](const std::vector<std::string>&args,
-									  std::size_t&idx,const std::string&name){
+	ArgParser&add_value(const std::string&opt,
+					   std::function<void(const std::string&)> action){
+		return add(opt,[fn=std::move(action)](const std::vector<std::string>&args,
+											 std::size_t&idx,
+											 const std::string&name){
 			fn(require_value(args,idx,name));
 		});
 	}

include/lunar/rt_solver.hpp

@@ -1,11 +1,6 @@
 #pragma once
 
-#include<atomic>
-#include<cstddef>
 #include<string>
-#include<vector>
-
-struct SolLunCal;
 
 struct RootTask{
 	std::string kind;
@@ -14,13 +9,3 @@ struct RootTask{
 	double eps_days;
 	int max_iter;
 };
-
-struct RootCtx{
-	SolLunCal*self;
-	const std::vector<RootTask>*tasks;
-	std::vector<double>*results;
-	std::vector<std::string>*errors;
-	std::atomic<std::size_t>*cursor;
-};
-
-void run_wkr(RootCtx*ctx);

include/lunar/spc_ephem.hpp

@@ -2,7 +2,6 @@
 
 #include<map>
 #include<memory>
-#include<mutex>
 #include<string>
 #include<utility>
 #include<vector>
@@ -38,7 +37,7 @@ struct EphRead{
 	int MOON;
 	std::map<int,std::string> id_name;
 	std::shared_ptr<SpkFile> kern;
-	std::once_flag kern_flag;
+	bool kern_loaded=false;
 	bool use_series=false;
 
 	explicit EphRead(const std::string&path);

src/calendar.cpp

@@ -6,15 +6,11 @@
 #include<iomanip>
 #include<iostream>
 #include<limits>
-#include<memory>
 #include<stdexcept>
-#include<thread>
 #include<vector>
 
 namespace{
 
-constexpr std::size_t kMaxWork=8;
-
 std::string clean_txt(std::string text){
 	for(char&c : text){
 		if(c=='\t'||c=='\r'||c=='\n'){
@@ -306,65 +302,16 @@ SolLunCal::run_roots(const std::vector<RootTask>&tasks){
 		return {results,errors};
 	}
 
-	auto run_serial=[&](){
-		for(std::size_t idx=0;idx<tasks.size();++idx){
-			const auto&task=tasks[idx];
-			try{
-				results[idx]=newton(task.kind,task.jd_initial,task.target,
-									task.eps_days,task.max_iter);
-			}catch(const std::exception&ex){
-				errors[idx]=ex.what();
-			}catch(...){
-				errors[idx]="unknown error";
-			}
-		}
-	};
-
-	if(tasks.size()==1){
-		run_serial();
-		return {results,errors};
-	}
-
-	unsigned int hc=std::thread::hardware_concurrency();
-	std::size_t wk_count=hc==0?4:static_cast<std::size_t>(hc);
-	wk_count=std::min<std::size_t>(wk_count,tasks.size());
-	wk_count=std::min<std::size_t>(wk_count,kMaxWork);
-	if(wk_count<=1){
-		run_serial();
-		return {results,errors};
-	}
-
-	try{
-		std::vector<std::unique_ptr<SolLunCal>> workers;
-		workers.reserve(wk_count);
-		for(std::size_t i=0;i<wk_count;++i){
-			workers.push_back(std::make_unique<SolLunCal>(eph));
-		}
-
-		std::atomic<std::size_t> cursor{0};
-		std::vector<RootCtx> ctxs(wk_count);
-		std::vector<std::thread> threads;
-		threads.reserve(wk_count);
-
+	for(std::size_t idx=0;idx<tasks.size();++idx){
+		const auto&task=tasks[idx];
 		try{
-			for(std::size_t i=0;i<wk_count;++i){
-				ctxs[i]={workers[i].get(),&tasks,&results,&errors,&cursor};
-				threads.emplace_back(run_wkr,&ctxs[i]);
-			}
+			results[idx]=newton(task.kind,task.jd_initial,task.target,
+								task.eps_days,task.max_iter);
+		}catch(const std::exception&ex){
+			errors[idx]=ex.what();
 		}catch(...){
-			for(auto&th : threads){
-				if(th.joinable()){
-					th.join();
-				}
-			}
-			throw;
+			errors[idx]="unknown error";
 		}
-
-		for(auto&th : threads){
-			th.join();
-		}
-	}catch(...){
-		run_serial();
 	}
 
 	return {results,errors};