CSLModels.h

Go to the documentation of this file.

 
 
#ifndef _CSLModels_h_
#define _CSLModels_h_
 
namespace XPMP2 {
 
typedef std::map<std::string,std::string> mapCSLPackageTy;
 
enum ObjLoadStateTy {
    OLS_INVALID = -1,       
    OLS_UNAVAIL = 0,        
    OLS_COPYING,            
    OLS_LOADING,            
    OLS_AVAILABLE,          
};
 
class CSLObj
{
public:
    std::string cslKey;     
    std::string path;       
    std::string pathOrig;   
    std::string texture;    
    std::string text_lit;   
 
protected:
    XPLMObjectRef       xpObj = NULL;
    ObjLoadStateTy xpObjState = OLS_UNAVAIL;
    
public:
    CSLObj (const std::string& _cslKey,
            const std::string& _path) : cslKey(_cslKey), path(_path) {}
    CSLObj (CSLObj&& o) = default;
    CSLObj& operator = (CSLObj&& o) = default;
    ~CSLObj ();
    
    ObjLoadStateTy GetObjState () const         { return xpObjState; }
    bool IsInvalid () const                     { return xpObjState == OLS_INVALID; }
 
    void DetermineWhichObjToLoad ();
 
    float FetchVertOfsFromObjFile () const;
    
    XPLMObjectRef GetAndLoadObj ();
    void Load ();
    void Unload ();
    
    bool NeedsObjCopy () const { return !pathOrig.empty(); }
 
protected:
    
    bool TriggerCopyAndReplace ();
    void SetCopyResult (bool bResult);
    static void SetOtherObjCopyResult (bool bResult);
    
    bool CopyAndReplace ();
    
    static void XPObjLoadedCB (XPLMObjectRef inObject,
                               void *        inRefcon);
    void Invalidate ();
};
 
typedef std::list<CSLObj> listCSLObjTy;
 
typedef std::pair<std::string,std::string> pairOfStrTy;
 
class CSLModel
{
public:
    struct MatchCritTy {
    protected:
        std::string         icaoAirline;
        int                 relOp = 0;      
    public:
        std::string         livery;
        
        void setAirline (const std::string& _icaoOp)
        { relOp = RelatedGet(REL_TXT_OP, icaoAirline = _icaoOp); }
        
        const std::string& getAirline () const { return icaoAirline; }  
        int getRelOp () const { return relOp; }                         
        
        bool merge (const MatchCritTy& o);
    };
    typedef std::vector<MatchCritTy> MatchCritVecTy;
public:
    std::string         shortId;
    std::string         cslId;
    std::string         modelName;
    std::uint16_t       pkgHash = 0;
    MatchCritVecTy      vecMatchCrit;
    listCSLObjTy        listObj;
    float               vertOfs = 3.0f;
    bool                bVertOfsReadFromFile = true;
    
    std::string         xsbAircraftPath;
    int                 xsbAircraftLn = 0;
 
protected:
    std::string         icaoType;
    const Doc8643*      doc8643 = nullptr;
    int                 related = 0;
    unsigned            refCnt = 0;
    float               refZeroTs = 0.0f;
    std::future<float>  futVertOfs;
    
public:
    CSLModel () {}
    CSLModel (CSLModel&& o) = default;
    CSLModel& operator = (CSLModel&& o) = default;
 
    virtual ~CSLModel ();
    
    void AddMatchCriteria (const std::string& _type,
                           const MatchCritTy& _matchCrit,
                           int lnNr);
    void CompModelName ();
    
    bool IsValid () const { return !cslId.empty() && !icaoType.empty() && !listObj.empty(); }
    
    const std::string& GetShortId () const      { return shortId; }     
    const std::string& GetId () const           { return cslId; }       
    const std::string& GetModelName () const    { return modelName; }   
    const std::string& GetIcaoType () const     { return icaoType; }    
    const std::string& GetIcaoAirline () const  { return vecMatchCrit.at(0).getAirline(); }
    const std::string& GetLivery () const       { return vecMatchCrit.at(0).livery; }      
    int GetRelatedGrp () const                  { return related; }     
    std::string GetKeyString () const;          
 
    // Data from Doc8643
    const Doc8643& GetDoc8643 () const          { return *doc8643; }    
    const char* GetWTC () const                 { return doc8643->wtc; }
    char GetClassType () const                  { return doc8643->GetClassType(); }
    char GetClassNumEng () const                { return doc8643->GetClassNumEng(); }
    int  GetNumEngines() const                  { return doc8643->GetNumEngines(); }
    char GetClassEngType () const               { return doc8643->GetClassEngType(); }
    bool HasRotor () const                      { return doc8643->HasRotor(); }
 
    float GetVertOfs () const                   { return vertOfs; }
        
    ObjLoadStateTy GetObjState () const;
    bool IsObjInvalid () const                  { return GetObjState() == OLS_INVALID; }
    
    std::list<XPLMObjectRef> GetAllObjRefs ();
    
    void IncRefCnt () { ++refCnt; }
    void DecRefCnt ();
    unsigned GetRefCnt () const { return refCnt; }
    
    static float GarbageCollection (float  inElapsedSinceLastCall,
                                    float  inElapsedTimeSinceLastFlightLoop,
                                    int    inCounter,
                                    void * inRefcon);
 
protected:
    void Unload ();
    float FetchVertOfsFromObjFile () const;
};
 
typedef std::map<std::string,CSLModel> mapCSLModelTy;
 
typedef std::multimap<unsigned long,std::pair<CSLModel*,const CSLModel::MatchCritTy*> > mmapCSLModelPTy;
 
//
// MARK: Global Functions
//
 
void CSLModelsInit ();
 
void CSLModelsCleanup ();
 
const char* CSLModelsLoad (const std::string& _path,
                           int _maxDepth = 5);
 
CSLModel* CSLModelById (const std::string& _cslId,
                        mapCSLModelTy::iterator* _pOutIter = nullptr);
 
CSLModel* CSLModelByKey(const std::string& _cslKey,
                        mapCSLModelTy::iterator* _pOutIter = nullptr);
 
int CSLModelMatching (const std::string& _type,
                      const std::string& _airline,
                      const std::string& _livery,
                      CSLModel* &pModel);
 
}       // namespace XPMP2
 
#endif