#include <simgear/math/sg_geodesy.hxx>
#include <simgear/debug/logstream.hxx>
-#include STL_IOSTREAM
+#include <istream>
+#include <ostream>
+
#include STL_STRING
#include "ATCVoice.hxx"
// This might move or change eventually
struct PlaneRec {
plane_type type;
- string callsign;
+ std::string callsign;
int squawkcode;
};
unsigned short int freq;
//int range;
unsigned short int range;
- string ident;
- string name;
+ std::string ident;
+ std::string name;
};
// perhaps we could use an FGRunway instead of this.
double hdg; // true runway heading
double length; // In *METERS*
double width; // ditto
- string rwyID;
+ std::string rwyID;
int patternDirection; // -1 for left, 1 for right
};
-ostream& operator << (ostream& os, atc_type atc);
+std::ostream& operator << (std::ostream& os, atc_type atc);
class FGATC {
virtual void ReceiveUserCallback(int code);
// Add plane to a stack
- virtual void AddPlane(const string& pid);
+ virtual void AddPlane(const std::string& pid);
// Remove plane from stack
virtual int RemovePlane();
inline void SetNoDisplay() { _display = false; }
// Generate the text of a message from its parameters and the current context.
- virtual string GenText(const string& m, int c);
+ virtual std::string GenText(const std::string& m, int c);
// Returns true if OK to transmit on this frequency
inline bool GetFreqClear() { return freqClear; }
// Indicate that the frequency is in use
inline void SetFreqInUse() { freqClear = false; receiving = true; }
// Transmission to the ATC is finished and a response is required
- void SetResponseReqd(const string& rid);
+ void SetResponseReqd(const std::string& rid);
// Transmission finished - let ATC decide if a response is reqd and clear freq if necessary
- void NotifyTransmissionFinished(const string& rid);
+ void NotifyTransmissionFinished(const std::string& rid);
// Transmission finished and no response required
inline void ReleaseFreq() { freqClear = true; receiving = false; } // TODO - check that the plane releasing the freq is the right one etc.
// The above 3 funcs under development!!
inline void set_freq(const int fq) {freq = fq;}
inline int get_range() const { return range; }
inline void set_range(const int rg) {range = rg;}
- inline const string& get_ident() { return ident; }
- inline void set_ident(const string& id) { ident = id; }
- inline const string& get_name() { return name; }
- inline void set_name(const string& nm) { name = nm; }
+ inline const std::string& get_ident() { return ident; }
+ inline void set_ident(const std::string& id) { ident = id; }
+ inline const std::string& get_name() { return name; }
+ inline void set_name(const std::string& nm) { name = nm; }
protected:
// Outputs the transmission either on screen or as audio depending on user preference
// The refname is a string to identify this sample to the sound manager
// The repeating flag indicates whether the message should be repeated continuously or played once.
- void Render(string& msg, const string& refname = "", bool repeating = false);
+ void Render(std::string& msg, const std::string& refname = "", bool repeating = false);
// Cease rendering all transmission from this station.
// Requires the sound manager refname if audio, else "".
- void NoRender(const string& refname);
+ void NoRender(const std::string& refname);
// Transmit a message when channel becomes free of other dialog
void Transmit(int callback_code = 0);
double x, y, z;
int freq;
int range;
- string ident; // Code of the airport its at.
- string name; // Name transmitted in the broadcast.
+ std::string ident; // Code of the airport its at.
+ std::string name; // Name transmitted in the broadcast.
atc_type _type;
// Rendering related stuff
bool _voiceOK; // Flag - true if at least one voice has loaded OK
FGATCVoice* _vPtr;
- string pending_transmission; // derived classes set this string before calling Transmit(...)
+ std::string pending_transmission; // derived classes set this string before calling Transmit(...)
bool freqClear; // Flag to indicate if the frequency is clear of ongoing dialog
bool receiving; // Flag to indicate we are receiving a transmission
bool responseReqd; // Flag to indicate we should be responding to a request/report
double responseTime; // Time to take from end of request transmission to beginning of response
// The idea is that this will be slightly random.
double responseCounter; // counter to implement the above
- string responseID; // ID of the plane to respond to
+ std::string responseID; // ID of the plane to respond to
bool respond; // Flag to indicate now is the time to respond - ie set following the count down of the response timer.
// Derived classes only need monitor this flag, and use the response ID, as long as they call FGATC::Update(...)
bool _runReleaseCounter; // A timer for releasing the frequency after giving the message enough time to display
double _max_count;
};
-inline istream&
-operator >> ( istream& fin, ATCData& a )
+inline std::istream&
+operator >> ( std::istream& fin, ATCData& a )
{
double f;
char ch;
if(ch != '"') a.name += ch;
while(1) {
//in >> noskipws
- fin.unsetf(ios::skipws);
+ fin.unsetf(std::ios::skipws);
fin >> ch;
if((ch == '"') || (ch == 0x0A)) {
break;
} // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
a.name += ch;
}
- fin.setf(ios::skipws);
+ fin.setf(std::ios::skipws);
//cout << "Comm name = " << a.name << '\n';
a.freq = (int)(f*100.0 + 0.5);
# include <config.h>
#endif
+#include <iostream>
+
#include <simgear/structure/exception.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/sg_inlines.h>
#include "xmlauto.hxx"
+using std::cout;
+using std::endl;
FGPIDController::FGPIDController( SGPropertyNode *node ):
debug( false ),
#endif
#include <stdio.h> // FILE*, fopen(), fread(), fwrite(), et. al.
+#include <iostream> // for cout, endl
#include <simgear/debug/logstream.hxx>
#include <simgear/io/lowlevel.hxx> // endian tests
#include "ExternalPipe.hxx"
+using std::cout;
+using std::endl;
static const int MAX_BUF = 32768;
#include <string>
#ifdef FGFS
# include <simgear/props/props.hxx>
+# include <simgear/debug/logstream.hxx>
+# define JSBDEBUG sglog() << loglevel(SG_FLIGHT, SG_ALERT)
#else
+# include <iostream>
# include "simgear/props/props.hxx"
+# define JSBDEBUG std::cout
#endif
#include "FGJSBBase.h"
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
-using namespace std;
-
namespace JSBSim {
+ // Yuck - shouldn't be using in header files
+ using std::string;
+ using std::endl;
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
Tie (const string &name, V (*getter)(), void (*setter)(V) = 0, bool useDefault = true)
{
if (!tie(name.c_str(), SGRawValueFunctions<V>(getter, setter), useDefault))
- cout << "Failed to tie property " << name << " to functions" << endl;
+ JSBDEBUG << "Failed to tie property " << name << " to functions" << endl;
else if (debug_lvl & 0x20)
- cout << name << endl;
+ JSBDEBUG << name << endl;
}
void (*setter)(int, V) = 0, bool useDefault = true)
{
if (!tie(name.c_str(), SGRawValueFunctionsIndexed<V>(index, getter, setter), useDefault))
- cout << "Failed to tie property " << name << " to indexed functions" << endl;
+ JSBDEBUG << "Failed to tie property " << name << " to indexed functions" << endl;
else if (debug_lvl & 0x20)
- cout << name << endl;
+ JSBDEBUG << name << endl;
}
void (T::*setter)(V) = 0, bool useDefault = true)
{
if (!tie(name.c_str(), SGRawValueMethods<T,V>(*obj, getter, setter), useDefault))
- cout << "Failed to tie property " << name << " to object methods" << endl;
+ JSBDEBUG << "Failed to tie property " << name << " to object methods" << endl;
else if (debug_lvl & 0x20)
- cout << name << endl;
+ JSBDEBUG << name << endl;
}
/**
void (T::*setter)(int, V) = 0, bool useDefault = true)
{
if (!tie(name.c_str(), SGRawValueMethodsIndexed<T,V>(*obj, index, getter, setter), useDefault))
- cout << "Failed to tie property " << name << " to indexed object methods" << endl;
+ JSBDEBUG << "Failed to tie property " << name << " to indexed object methods" << endl;
else if (debug_lvl & 0x20)
- cout << name << endl;
+ JSBDEBUG << name << endl;
}
};
}
+#include <ostream>
+
#include <simgear/debug/logstream.hxx>
#include "Math.hpp"
#include <stdio.h>
#include <string.h>
namespace yasim {
+using std::endl;
+
const float pi=3.14159;
float _help = 0;
Rotorpart::Rotorpart()
int pw=0, ph=0;
w.calcPrefSize(&pw, &ph);
w.layout(0, 0, pw, ph);
- writeProperties(cout, &props, true);
+ writeProperties(std::cout, &props, true);
}
// new_gui.cxx: implementation of XML-configurable GUI support.
+#include <iostream>
#include "new_gui.hxx"
// FGColor class.
////////////////////////////////////////////////////////////////////////
+void
+FGColor::print() const {
+ std::cerr << "red=" << _red << ", green=" << _green
+ << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
+}
+
bool
FGColor::merge(const SGPropertyNode *node)
{
bool isValid() const {
return _red >= 0.0 && _green >= 0.0 && _blue >= 0.0;
}
- void print() const {
- std::cerr << "red=" << _red << ", green=" << _green
- << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
- }
+ void print() const;
inline void setRed(float red) { _red = red; }
inline void setGreen(float green) { _green = green; }
#include <sstream>
#include STL_IOMANIP
+#include <iostream>
#include STL_STRING
SG_USING_STD(string);
+using std::cout;
+
typedef string stdString; // puObject has a "string" member
#include <Main/fg_os.hxx> // fgGetKeyModifiers()
#include <iomanip>
#include <sstream>
+#include <iostream>
#include <string.h>
#include <simgear/debug/logstream.hxx>
#include <math.h>
#include <algorithm>
+#include <iostream>
#include <simgear/compiler.h>
SG_USING_STD(sort);
+using std::cerr;
+using std::endl;
+
/**************************************************************************
* FGNode
*************************************************************************/
#define _AIRWAYNETWORK_HXX_
#include STL_STRING
-#include <fstream>
+#include <istream>
#include <set>
#include <map>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(map);
-SG_USING_STD(set);
-SG_USING_STD(vector);
-SG_USING_STD(fstream);
-
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/sgstream.hxx>
class FGAirway; // forward reference
-typedef vector<FGAirway> FGAirwayVector;
-typedef vector<FGAirway *> FGAirwayPointerVector;
-typedef vector<FGAirway>::iterator FGAirwayVectorIterator;
-typedef vector<FGAirway*>::iterator FGAirwayPointerVectorIterator;
+typedef std::vector<FGAirway> FGAirwayVector;
+typedef std::vector<FGAirway *> FGAirwayPointerVector;
+typedef std::vector<FGAirway>::iterator FGAirwayVectorIterator;
+typedef std::vector<FGAirway*>::iterator FGAirwayPointerVectorIterator;
/**************************************************************************************
* class FGNode
class FGNode
{
private:
- string ident;
+ std::string ident;
double lat;
double lon;
int index;
public:
FGNode();
- FGNode(double lt, double ln, int idx, string id) { lat = lt; lon = ln; index = idx; ident = id;};
+ FGNode(double lt, double ln, int idx, std::string id) { lat = lt; lon = ln; index = idx; ident = id;};
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 setLatitude (const std::string& val) { lat = processPosition(val); };
+ //void setLongitude(const std::string& val) { lon = processPosition(val); };
void addAirway(FGAirway *segment) { next.push_back(segment); };
double getLatitude() { return lat;};
double getLongitude(){ return lon;};
int getIndex() { return index; };
- string getIdent() { return ident; };
+ std::string getIdent() { return ident; };
FGNode *getAddress() { return this;};
FGAirwayPointerVectorIterator getBeginRoute() { return next.begin(); };
FGAirwayPointerVectorIterator getEndRoute() { return next.end(); };
- bool matches(string ident, double lat, double lon);
+ bool matches(std::string ident, double lat, double lon);
};
-typedef vector<FGNode *> FGNodeVector;
-typedef vector<FGNode *>::iterator FGNodeVectorIterator;
+typedef std::vector<FGNode *> FGNodeVector;
+typedef std::vector<FGNode *>::iterator FGNodeVectorIterator;
-typedef map < string, FGNode *> node_map;
+typedef std::map < std::string, FGNode *> node_map;
typedef node_map::iterator node_map_iterator;
typedef node_map::const_iterator const_node_map_iterator;
class FGAirway
{
private:
- string startNode;
- string endNode;
+ std::string startNode;
+ std::string endNode;
double length;
FGNode *start;
FGNode *end;
int type; // 1=low altitude; 2=high altitude airway
int base; // base altitude
int top; // top altitude
- string name;
+ std::string name;
public:
FGAirway();
FGAirway(FGNode *, FGNode *, int);
void setIndex (int val) { index = val; };
- void setStartNodeRef (string val) { startNode = val; };
- void setEndNodeRef (string val) { endNode = val; };
+ void setStartNodeRef (std::string val) { startNode = val; };
+ void setEndNodeRef (std::string val) { endNode = val; };
void setStart(node_map *nodes);
void setEnd (node_map *nodes);
void setType (int tp) { type = tp;};
void setBase (int val) { base = val;};
void setTop (int val) { top = val;};
- void setName (string val) { name = val;};
+ void setName (std::string val) { name = val;};
void setTrackDistance();
FGNode * getEnd() { return end;};
double getLength() { if (length == 0) setTrackDistance(); return length; };
int getIndex() { return index; };
- string getName() { return name; };
+ std::string getName() { return name; };
};
-typedef vector<int> intVec;
-typedef vector<int>::iterator intVecIterator;
-typedef vector<int>::const_iterator constIntVecIterator;
+typedef std::vector<int> intVec;
+typedef std::vector<int>::iterator intVecIterator;
+typedef std::vector<int>::const_iterator constIntVecIterator;
class FGAirRoute
{
void add(const FGAirRoute &other);
void add(int node) {nodes.push_back(node);};
- friend istream& operator >> (istream& in, FGAirRoute& r);
+ friend std::istream& operator >> (std::istream& in, FGAirRoute& r);
};
-inline istream& operator >> ( istream& in, FGAirRoute& r )
+inline std::istream& operator >> ( std::istream& in, FGAirRoute& r )
{
int node;
in >> node;
return in;
}
-typedef vector<FGAirRoute> AirRouteVector;
-typedef vector<FGAirRoute>::iterator AirRouteVectorIterator;
+typedef std::vector<FGAirRoute> AirRouteVector;
+typedef std::vector<FGAirRoute>::iterator AirRouteVectorIterator;
/**************************************************************************************
* class FGAirwayNetwork
{ }
~FGATCMain() {
- cout << "FGATCMain destructor" << endl;
delete input0;
delete input1;
delete output0;
# include "config.h"
#endif
+#include <iostream>
+
#include <simgear/debug/logstream.hxx>
#include <simgear/math/sg_geodesy.hxx>
#include <simgear/io/iochannel.hxx>
garmin_sentence += gsa;
garmin_sentence += "\r\n";
- cout << garmin_sentence;
+ std::cout << garmin_sentence;
length = garmin_sentence.length();
strncpy( buf, garmin_sentence.c_str(), length );
#include "httpd.hxx"
SG_USING_STD(string);
-SG_USING_STD(cout);
-
bool FGHttpd::open() {
if ( is_enabled() ) {
#include <simgear/props/props_io.hxx>
#include <sstream>
+#include <iostream>
#include <Main/globals.hxx>
#include <Main/viewmgr.hxx>
SG_USING_STD(stringstream);
SG_USING_STD(ends);
+using std::cout;
+using std::endl;
+
/**
* Props connection class.
* This class represents a connection to props client.
#include <simgear/structure/exception.hxx>
#include <simgear/misc/sg_path.hxx>
+#include <simgear/debug/logstream.hxx>
#include <Main/fg_props.hxx>
#include <Main/globals.hxx>
" " );
if ( node->apply_load( load, dt ) < 0.0 ) {
- cout << "Error drawing more current than available!" << endl;
+ SG_LOG(SG_ALL, SG_ALERT,
+ "Error drawing more current than available!");
}
}
}
" " );
if ( node->apply_load( load, dt ) < 0.0 ) {
- cout << "Error drawing more current than available!" << endl;
+ SG_LOG(SG_ALL, SG_ALERT,
+ "Error drawing more current than available!");
}
}
}
// cout << "battery load = " << load << endl;
if ( node->apply_load( load, dt ) < 0.0 ) {
- cout << "Error drawing more current than available!" << endl;
+ SG_LOG(SG_ALL, SG_ALERT,
+ "Error drawing more current than available!");
}
}
}
projects / flightgear.git / commitdiff