TLEDatabaseQuery.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/StringView.hpp"
#include "AstCore/TimePoint.hpp"
#include <string>
 
AST_NAMESPACE_BEGIN
 
class TLE;
 
class AST_CORE_API TLEDatabaseQuery
{
public:
    TLEDatabaseQuery();
 
    ~TLEDatabaseQuery();
 
    // -- 名称过滤（子串匹配）--
 
    void setName(StringView pattern);
 
    const std::string& name() const { return name_; }
 
    // -- NORAD 编号过滤（精确匹配）--
 
    void setNoradId(int id);
    void clearNoradId();
    bool hasNoradId() const { return hasNoradId_; }
    int noradId() const { return noradId_; }
 
    // -- 历元时间范围过滤 --
 
    void setMinEpoch(const TimePoint& v);
    void setMaxEpoch(const TimePoint& v);
    void clearMinEpoch();
    void clearMaxEpoch();
    bool useMinEpoch() const { return useMinEpoch_; }
    bool useMaxEpoch() const { return useMaxEpoch_; }
    const TimePoint& minEpoch() const { return minEpoch_; }
    const TimePoint& maxEpoch() const { return maxEpoch_; }
 
    // -- 密级过滤 --
 
    void setClassification(char c);
    void clearClassification();
    bool hasClassification() const { return hasClassification_; }
    char classification() const { return classification_; }
 
    // -- 轨道参数范围过滤 --
 
    void setMinInclination(double v);
    void setMaxInclination(double v);
    void clearMinInclination();
    void clearMaxInclination();
    bool useMinInclination() const { return useMinInclination_; }
    bool useMaxInclination() const { return useMaxInclination_; }
    double minInclination() const { return minInclination_; }
    double maxInclination() const { return maxInclination_; }
 
    void setMinEccentricity(double v);
    void setMaxEccentricity(double v);
    void clearMinEccentricity();
    void clearMaxEccentricity();
    bool useMinEccentricity() const { return useMinEccentricity_; }
    bool useMaxEccentricity() const { return useMaxEccentricity_; }
    double minEccentricity() const { return minEccentricity_; }
    double maxEccentricity() const { return maxEccentricity_; }
 
    void setMinMeanMotion(double v);
    void setMaxMeanMotion(double v);
    void clearMinMeanMotion();
    void clearMaxMeanMotion();
    bool useMinMeanMotion() const { return useMinMeanMotion_; }
    bool useMaxMeanMotion() const { return useMaxMeanMotion_; }
    double minMeanMotion() const { return minMeanMotion_; }
    double maxMeanMotion() const { return maxMeanMotion_; }
 
    void setMinBstar(double v);
    void setMaxBstar(double v);
    void clearMinBstar();
    void clearMaxBstar();
    bool useMinBstar() const { return useMinBstar_; }
    bool useMaxBstar() const { return useMaxBstar_; }
    double minBstar() const { return minBstar_; }
    double maxBstar() const { return maxBstar_; }
 
    // -- 匹配 --
 
    bool matches(const TLE& tle) const;
 
    bool isEmpty() const;
 
private:
    std::string name_{};              
    int noradId_{0};                  
    bool hasNoradId_{false};          
    TimePoint minEpoch_{};            
    TimePoint maxEpoch_{};            
    bool useMinEpoch_{false};         
    bool useMaxEpoch_{false};         
    char classification_{'U'};        
    bool hasClassification_{false};   
    double minInclination_{0.0};      
    double maxInclination_{0.0};      
    bool useMinInclination_{false};   
    bool useMaxInclination_{false};   
    double minEccentricity_{0.0};     
    double maxEccentricity_{0.0};     
    bool useMinEccentricity_{false};  
    bool useMaxEccentricity_{false};  
    double minMeanMotion_{0.0};       
    double maxMeanMotion_{0.0};       
    bool useMinMeanMotion_{false};    
    bool useMaxMeanMotion_{false};    
    double minBstar_{0.0};            
    double maxBstar_{0.0};            
    bool useMinBstar_{false};         
    bool useMaxBstar_{false};         
};
 
AST_NAMESPACE_END