#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
-
+#include <simgear/math/point3d.hxx>
+#include <simgear/route/waypoint.hxx>
#include <simgear/compiler.h>
#include <simgear/xml/easyxml.hxx>
typedef vector<time_t> timeVec;
typedef vector<time_t>::const_iterator timeVecConstIterator;
+
+
/***************************************************************************/
class ScheduleTime {
private:
void clear();
void addStartTime(time_t time) { start.push_back(time); };
void addEndTime (time_t time) { end. push_back(time); };
- void addScheduleName(string sched) { scheduleNames.push_back(sched); };
+ void addScheduleName(const string& sched) { scheduleNames.push_back(sched); };
void setTailWind(double wnd) { tailWind = wnd; };
void setCrossWind(double wnd) { tailWind = wnd; };
RunwayList(const RunwayList &other);
RunwayList& operator= (const RunwayList &other);
- void set(string, string);
+ void set(const string&, const string&);
void clear();
string getType() { return type; };
void setName(string nm) { name = nm; };
void add(RunwayList list) { rwyList.push_back(list);};
- void setActive(string aptId, double windSpeed, double windHeading, double maxTail, double maxCross);
+ void setActive(const string& aptId, double windSpeed, double windHeading, double maxTail, double maxCross);
int getNrActiveRunways() { return nrActive;};
- void getActive(int i, string *name, string *type);
+ void getActive(int i, string& name, string& type);
string getName() { return name; };
void clear() { rwyList.clear(); };
RunwayGroup rwyGroup;
PreferenceList preferences;
- time_t processTime(string);
+ time_t processTime(const string&);
bool initialized;
public:
FGRunwayPreference & operator= (const FGRunwayPreference &other);
ScheduleTime *getSchedule(const char *trafficType);
- RunwayGroup *getGroup(const string groupName);
+ RunwayGroup *getGroup(const string& groupName);
bool available() { return initialized; };
// Some overloaded virtual XMLVisitor members
virtual void error (const char * message, int line, int column);
};
+double processPosition(const string& pos);
+
class FGParking {
private:
double latitude;
string type;
string airlineCodes;
-
bool available;
- double processPosition(string pos);
+
public:
FGParking() { available = true;};
double hdg,
double rad,
int idx,
- string name,
- string tpe,
- string codes);
- void setLatitude (string lat) { latitude = processPosition(lat); };
- void setLongitude(string lon) { longitude = processPosition(lon); };
+ const string& name,
+ const string& tpe,
+ const string& codes);
+ void setLatitude (const string& lat) { latitude = processPosition(lat); };
+ void setLongitude(const string& lon) { longitude = processPosition(lon); };
void setHeading (double hdg) { heading = hdg; };
void setRadius (double rad) { radius = rad; };
void setIndex (int idx) { index = idx; };
- void setName (string name) { parkingName = name; };
- void setType (string tpe) { type = tpe; };
- void setCodes (string codes){ airlineCodes= codes;};
+ void setName (const string& name) { parkingName = name; };
+ void setType (const string& tpe) { type = tpe; };
+ void setCodes (const string& codes){ airlineCodes= codes;};
bool isAvailable () { return available;};
void setAvailable(bool val) { available = val; };
typedef vector<FGParking>::iterator FGParkingVecIterator;
typedef vector<FGParking>::const_iterator FGParkingVecConstIterator;
+class FGTaxiSegment; // forward reference
+
+typedef vector<FGTaxiSegment> FGTaxiSegmentVector;
+typedef vector<FGTaxiSegment*> FGTaxiSegmentPointerVector;
+typedef vector<FGTaxiSegment>::iterator FGTaxiSegmentVectorIterator;
+typedef vector<FGTaxiSegment*>::iterator FGTaxiSegmentPointerVectorIterator;
+
+/**************************************************************************************
+ * class FGTaxiNode
+ *************************************************************************************/
+class FGTaxiNode
+{
+private:
+ double lat;
+ double lon;
+ int index;
+ FGTaxiSegmentPointerVector next; // a vector to all the segments leaving from this node
+
+public:
+ FGTaxiNode();
+ FGTaxiNode(double, double, int);
+
+ void setIndex(int idx) { index = idx;};
+ void setLatitude (double val) { lat = val;};
+ void setLongitude(double val) { lon = val;};
+ void setLatitude (const string& val) { lat = processPosition(val); };
+ void setLongitude(const string& val) { lon = processPosition(val); };
+ void addSegment(FGTaxiSegment *segment) { next.push_back(segment); };
+
+ double getLatitude() { return lat;};
+ double getLongitude(){ return lon;};
+
+ int getIndex() { return index; };
+ FGTaxiNode *getAddress() { return this;};
+ FGTaxiSegmentPointerVectorIterator getBeginRoute() { return next.begin(); };
+ FGTaxiSegmentPointerVectorIterator getEndRoute() { return next.end(); };
+};
+
+typedef vector<FGTaxiNode> FGTaxiNodeVector;
+typedef vector<FGTaxiNode>::iterator FGTaxiNodeVectorIterator;
+
+/***************************************************************************************
+ * class FGTaxiSegment
+ **************************************************************************************/
+class FGTaxiSegment
+{
+private:
+ int startNode;
+ int endNode;
+ double length;
+ FGTaxiNode *start;
+ FGTaxiNode *end;
+ int index;
+
+public:
+ FGTaxiSegment();
+ FGTaxiSegment(FGTaxiNode *, FGTaxiNode *, int);
+
+ void setIndex (int val) { index = val; };
+ void setStartNodeRef (int val) { startNode = val; };
+ void setEndNodeRef (int val) { endNode = val; };
+
+ void setStart(FGTaxiNodeVector *nodes);
+ void setEnd (FGTaxiNodeVector *nodes);
+ void setTrackDistance();
+ FGTaxiNode * getEnd() { return end;};
+ double getLength() { return length; };
+ int getIndex() { return index; };
+
+
+};
+
+
+typedef vector<int> intVec;
+typedef vector<int>::iterator intVecIterator;
+
+class FGTaxiRoute
+{
+private:
+ intVec nodes;
+ double distance;
+ intVecIterator currNode;
+
+public:
+ FGTaxiRoute() { distance = 0; currNode = nodes.begin(); };
+ FGTaxiRoute(intVec nds, double dist) { nodes = nds; distance = dist; currNode = nodes.begin();};
+ bool operator< (const FGTaxiRoute &other) const {return distance < other.distance; };
+ bool empty () { return nodes.begin() == nodes.end(); };
+ bool next(int *val);
+
+ void first() { currNode = nodes.begin(); };
+};
+
+typedef vector<FGTaxiRoute> TaxiRouteVector;
+typedef vector<FGTaxiRoute>::iterator TaxiRouteVectorIterator;
+
+/**************************************************************************************
+ * class FGGroundNetWork
+ *************************************************************************************/
+class FGGroundNetwork
+{
+private:
+ bool hasNetwork;
+ FGTaxiNodeVector nodes;
+ FGTaxiSegmentVector segments;
+ //intVec route;
+ intVec traceStack;
+ TaxiRouteVector routes;
+
+ bool foundRoute;
+ double totalDistance, maxDistance;
+
+public:
+ FGGroundNetwork();
+
+ void addNode (const FGTaxiNode& node);
+ void addNodes (FGParkingVec *parkings);
+ void addSegment(const FGTaxiSegment& seg);
+
+ void init();
+ bool exists() { return hasNetwork; };
+ int findNearestNode(double lat, double lon);
+ FGTaxiNode *findNode(int idx);
+ FGTaxiRoute findShortestRoute(int start, int end);
+ void trace(FGTaxiNode *, int, int, double dist);
+
+};
+
+/***************************************************************************************
+ *
+ **************************************************************************************/
class FGAirport : public XMLVisitor{
private:
string _id;
bool _has_metar;
FGParkingVec parkings;
FGRunwayPreference rwyPrefs;
+ FGGroundNetwork groundNetwork;
time_t lastUpdate;
string prevTrafficType;
double avWindHeading [10];
double avWindSpeed [10];
+ string chooseRunwayFallback();
+
public:
FGAirport();
FGAirport(const FGAirport &other);
//operator= (FGAirport &other);
- FGAirport(string id, double lon, double lat, double elev, string name, bool has_metar);
- void getActiveRunway(string trafficType, int action, string *runway);
- void chooseRunwayFallback(string *runway);
- bool getAvailableParking(double *lat, double *lon, double *heading, int *gate, double rad, string fltype,
- string acType, string airline);
+ FGAirport(const string& id, double lon, double lat, double elev, const string& name, bool has_metar);
+
+ void init();
+ void getActiveRunway(const string& trafficType, int action, string& runway);
+ bool getAvailableParking(double *lat, double *lon, double *heading, int *gate, double rad, const string& fltype,
+ const string& acType, const string& airline);
void getParking (int id, double *lat, double* lon, double *heading);
FGParking *getParking(int i); // { if (i < parkings.size()) return parkings[i]; else return 0;};
void releaseParking(int id);
string getParkingName(int i);
string getId() const { return _id;};
const string &getName() const { return _name;};
+ //FGAirport *getAddress() { return this; };
+ //const string &getName() const { return _name;};
// Returns degrees
double getLongitude() const { return _longitude;};
// Returns degrees
// Returns ft
double getElevation() const { return _elevation;};
bool getMetar() const { return _has_metar;};
+ FGGroundNetwork* getGroundNetwork() { return &groundNetwork; };
- void setId(string id) { _id = id;};
+ void setId(const string& id) { _id = id;};
void setMetar(bool value) { _has_metar = value; };
- void setRwyUse(FGRunwayPreference& ref);
+ void setRwyUse(const FGRunwayPreference& ref);
// Some overloaded virtual XMLVisitor members
virtual void startXML ();
~FGAirportList();
// add an entry to the list
- void add( const string id, const double longitude, const double latitude,
- const double elevation, const string name, const bool has_metar );
+ void add( const string& id, const double longitude, const double latitude,
+ const double elevation, const string& name, const bool has_metar );
// search for the specified id.
- // Returns NULL if unsucessfull.
+ // Returns NULL if unsucessfull.
FGAirport* search( const string& id );
// Search for the next airport in ASCII sequence to the supplied id.
projects / flightgear.git / blobdiff