fly/terragear
1
0
Fork 0
Code Activity

Adapt to changes in simgear/compiler.h (removal of STL_* and SG_USING_STD() macros).

Browse source
This commit is contained in:
Ralf Gerlich 2008-08-08 12:17:43 +02:00
parent e6d15f9a83
commit 4a35fedf64
78 changed files with 314 additions and 384 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/Airports/GenAirports/build.cxx
View file

@ -38,7 +38,7 @@
#include <list> #include <list>
#include <map> #include <map>
#include STL_STRING #include <string>
#include <plib/sg.h> // plib include #include <plib/sg.h> // plib include
@ -74,9 +74,9 @@
#include "build.hxx" #include "build.hxx"
SG_USING_STD(map); using std::map;
SG_USING_STD(less); using std::less;
SG_USING_STD(string); using std::string;
// calculate texture coordinates for runway section using the provided // calculate texture coordinates for runway section using the provided

4
src/Airports/GenAirports/convex_hull.cxx
View file

@ -34,8 +34,8 @@
#include <simgear/constants.h> #include <simgear/constants.h>
#include <simgear/structure/exception.hxx> #include <simgear/structure/exception.hxx>
SG_USING_STD(less); using std::less;
SG_USING_STD(map); using std::map;
#include <simgear/constants.h> #include <simgear/constants.h>

4
src/Airports/GenAirports/lights.cxx
View file

@ -33,8 +33,8 @@
#include "lights.hxx" #include "lights.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
// calculate the runway light direction vector. We take the center of // calculate the runway light direction vector. We take the center of

10
src/Airports/GenAirports/main.cxx
View file

@ -35,15 +35,15 @@
#include <list> #include <list>
#include <vector> #include <vector>
SG_USING_STD(vector); using std::vector;
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
#include <simgear/constants.h> #include <simgear/constants.h>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>

5
src/Airports/GenAirports/texparams.hxx
View file

@ -36,9 +36,6 @@
#include <vector> #include <vector>
SG_USING_STD(vector);
class TGTexParams { class TGTexParams {
private: private:
@ -95,7 +92,7 @@ public:
}; };
typedef vector < TGTexParams > texparams_list; typedef std::vector < TGTexParams > texparams_list;
typedef texparams_list::iterator texparams_list_iterator; typedef texparams_list::iterator texparams_list_iterator;
typedef texparams_list::const_iterator const_texparams_list_iterator; typedef texparams_list::const_iterator const_texparams_list_iterator;

6
src/BuildTiles/Clipper/clipper.cxx
View file

@ -37,10 +37,10 @@
#include "clipper.hxx" #include "clipper.hxx"
#include STL_IOSTREAM #include <iostream>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
#define MASK_CLIP 1 #define MASK_CLIP 1

11
src/BuildTiles/Clipper/clipper.hxx
View file

@ -39,12 +39,7 @@
#include <Polygon/polygon.hxx> #include <Polygon/polygon.hxx>
#include <Polygon/point2d.hxx> #include <Polygon/point2d.hxx>
#include STL_STRING #include <string>
#include <vector>
SG_USING_STD(string);
SG_USING_STD(vector);
#define TG_MAX_AREA_TYPES 128 // FIXME also defined in #define TG_MAX_AREA_TYPES 128 // FIXME also defined in
// MergerClipper/clipper.hxx // MergerClipper/clipper.hxx
@ -79,10 +74,10 @@ public:
bool init(); bool init();
// Load a polygon definition file // Load a polygon definition file
bool load_polys(const string& path); bool load_polys(const std::string& path);
// Load an Osgb36 polygon definition file // Load an Osgb36 polygon definition file
bool load_osgb36_polys(const string& path); bool load_osgb36_polys(const std::string& path);
// Add a polygon. // Add a polygon.
void add_poly(int area, const TGPolygon &poly); void add_poly(int area, const TGPolygon &poly);

6
src/BuildTiles/Clipper/priorities.cxx
View file

@ -24,12 +24,12 @@
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
#include <map> #include <map>
#include STL_STRING #include <string>
#include "priorities.hxx" #include "priorities.hxx"
SG_USING_STD(string); using std::string;
SG_USING_STD(map); using std::map;
typedef map<AreaType, string> area_type_map; typedef map<AreaType, string> area_type_map;
typedef map<string, AreaType> area_name_map; typedef map<string, AreaType> area_name_map;

9
src/BuildTiles/Clipper/priorities.hxx
View file

@ -27,10 +27,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
SG_USING_STD(string);
// Posible shape file types. Note the order of these is important and // Posible shape file types. Note the order of these is important and
// defines the priority of these shapes if they should intersect. The // defines the priority of these shapes if they should intersect. The
@ -102,10 +99,10 @@ enum AreaType {
// return area type from text name // return area type from text name
AreaType get_area_type( const string &area ); AreaType get_area_type( const std::string &area );
// return text form of area name // return text form of area name
string get_area_name( AreaType area ); std::string get_area_name( AreaType area );
#endif // _PRIORITIES_HXX #endif // _PRIORITIES_HXX

4
src/BuildTiles/Clipper/testclipper.cxx
View file

@ -27,8 +27,8 @@
#include "clipper.hxx" #include "clipper.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
int main( int argc, char **argv ) { int main( int argc, char **argv ) {

4
src/BuildTiles/GenOutput/genobj.cxx
View file

@ -40,8 +40,8 @@
#include "genobj.hxx" #include "genobj.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
// calculate the global bounding sphere. Center is the center of the // calculate the global bounding sphere. Center is the center of the

8
src/BuildTiles/GenOutput/genobj.hxx
View file

@ -33,8 +33,6 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include <simgear/math/sg_geodesy.hxx> #include <simgear/math/sg_geodesy.hxx>
@ -44,11 +42,7 @@
#include <Main/construct.hxx> #include <Main/construct.hxx>
#include <Triangulate/triangle.hxx> #include <Triangulate/triangle.hxx>
SG_USING_STD(string); typedef std::vector < int_list > tex_list;
SG_USING_STD(vector);
typedef vector < int_list > tex_list;
typedef tex_list::iterator tex_list_iterator; typedef tex_list::iterator tex_list_iterator;
typedef tex_list::const_iterator const_tex_list_iterator; typedef tex_list::const_iterator const_tex_list_iterator;

26
src/BuildTiles/Main/construct.hxx
View file

@ -37,7 +37,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include <vector>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
@ -48,10 +49,7 @@
#include <Clipper/clipper.hxx> #include <Clipper/clipper.hxx>
#include <Triangulate/trieles.hxx> #include <Triangulate/trieles.hxx>
SG_USING_STD(string); typedef std::vector < int_list > belongs_to_list;
typedef vector < int_list > belongs_to_list;
typedef belongs_to_list::iterator belongs_to_list_iterator; typedef belongs_to_list::iterator belongs_to_list_iterator;
typedef belongs_to_list::const_iterator belongs_to_list_tripoly_iterator; typedef belongs_to_list::const_iterator belongs_to_list_tripoly_iterator;
@ -61,11 +59,11 @@ class TGConstruct {
private: private:
// path to land-cover file (if any) // path to land-cover file (if any)
string cover; std::string cover;
// paths // paths
string work_base; std::string work_base;
string output_base; std::string output_base;
// flag indicating whether to align texture coords within the UK // flag indicating whether to align texture coords within the UK
// with the UK grid // with the UK grid
@ -119,14 +117,14 @@ public:
~TGConstruct(); ~TGConstruct();
// land cover file // land cover file
inline string get_cover () const { return cover; } inline std::string get_cover () const { return cover; }
inline void set_cover (const string &s) { cover = s; } inline void set_cover (const std::string &s) { cover = s; }
// paths // paths
inline string get_work_base() const { return work_base; } inline std::string get_work_base() const { return work_base; }
inline void set_work_base( const string s ) { work_base = s; } inline void set_work_base( const std::string s ) { work_base = s; }
inline string get_output_base() const { return output_base; } inline std::string get_output_base() const { return output_base; }
inline void set_output_base( const string s ) { output_base = s; } inline void set_output_base( const std::string s ) { output_base = s; }
// UK grid flag // UK grid flag
inline bool get_useUKGrid() const { return useUKGrid; } inline bool get_useUKGrid() const { return useUKGrid; }

14
src/BuildTiles/Main/main.cxx
View file

@ -42,8 +42,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <vector> #include <vector>
#include <plib/sg.h> #include <plib/sg.h>
@ -63,11 +63,11 @@
#include "construct.hxx" #include "construct.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
SG_USING_STD(vector); using std::vector;
vector<string> load_dirs; vector<string> load_dirs;

10
src/BuildTiles/Main/master.cxx
View file

@ -30,8 +30,8 @@
#include <sys/stat.h> // for stat() #include <sys/stat.h> // for stat()
#include <unistd.h> // for stat() #include <unistd.h> // for stat()
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
@ -44,9 +44,9 @@
// #include <Match/match.hxx> // #include <Match/match.hxx>
// #include <Triangulate/triangle.hxx> // #include <Triangulate/triangle.hxx>
SG_USING_STD(string); using std::string;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
// return true if file exists // return true if file exists

4
src/BuildTiles/Match/match.cxx
View file

@ -36,8 +36,8 @@
#include "match.hxx" #include "match.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
TGMatch::TGMatch( void ) { TGMatch::TGMatch( void ) {

4
src/BuildTiles/Osgb36/osgb36.cxx
View file

@ -21,12 +21,12 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include <math.h> #include <math.h>
#include "osgb36.hxx" #include "osgb36.hxx"
SG_USING_STD(cout); using std::cout;
double DEG_TO_RAD = 2.0 * 3.14159265358979323846264338327950288419716939967511 / 360.0; double DEG_TO_RAD = 2.0 * 3.14159265358979323846264338327950288419716939967511 / 360.0;
double RAD_TO_DEG = 360.0 / (2.0 * 3.14159265358979323846264338327950288419716939967511); double RAD_TO_DEG = 360.0 / (2.0 * 3.14159265358979323846264338327950288419716939967511);

4
src/BuildTiles/Osgb36/testosgb36.cxx
View file

@ -1,11 +1,11 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include STL_IOSTREAM #include <iostream>
#include "osgb36.hxx" #include "osgb36.hxx"
SG_USING_STD(cout); using std::cout;
static void Usage() { static void Usage() {
cout << "Usage is testosgb36 <lon> <lat>\n"; cout << "Usage is testosgb36 <lon> <lat>\n";

14
src/BuildTiles/Parallel/client.cxx
View file

@ -29,22 +29,22 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <vector> #include <vector>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(endl); using std::endl;
#define MAXBUF 1024 #define MAXBUF 1024
#define BUSY_WAIT_TIME 30 #define BUSY_WAIT_TIME 30
SG_USING_STD(string); using std::string;
SG_USING_STD(vector); using std::vector;
string work_base = "."; string work_base = ".";
string output_base = "."; string output_base = ".";

12
src/BuildTiles/Parallel/server.cxx
View file

@ -7,8 +7,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -25,10 +25,10 @@
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( cerr ); using std:: cerr ;
SG_USING_STD( endl ); using std:: endl ;
SG_USING_STD( string ); using std:: string ;
#if defined (__sun) || defined (__CYGWIN__) || defined(sgi) #if defined (__sun) || defined (__CYGWIN__) || defined(sgi)
# define WAIT_ANY (pid_t)-1 # define WAIT_ANY (pid_t)-1

4
src/BuildTiles/Triangulate/triangle.cxx
View file

@ -28,8 +28,8 @@
#include "triangle.hxx" #include "triangle.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
// Constructor // Constructor

5
src/BuildTiles/Triangulate/trieles.hxx
View file

@ -34,9 +34,6 @@
#include <vector> #include <vector>
SG_USING_STD(vector);
// a segment is two integer pointers into the node list // a segment is two integer pointers into the node list
class TGTriEle { class TGTriEle {
int n1, n2, n3; int n1, n2, n3;
@ -65,7 +62,7 @@ public:
}; };
typedef vector < TGTriEle > triele_list; typedef std::vector < TGTriEle > triele_list;
typedef triele_list::iterator triele_list_iterator; typedef triele_list::iterator triele_list_iterator;
typedef triele_list::const_iterator const_triele_list_iterator; typedef triele_list::const_iterator const_triele_list_iterator;

10
src/Lib/Array/array.cxx
View file

@ -27,8 +27,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <simgear/constants.h> #include <simgear/constants.h>
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
@ -41,9 +41,9 @@
#include "array.hxx" #include "array.hxx"
SG_USING_STD(string); using std::string;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
TGArray::TGArray( void ): TGArray::TGArray( void ):

6
src/Lib/Array/array.hxx
View file

@ -35,17 +35,11 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <vector>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include <simgear/math/sg_types.hxx> #include <simgear/math/sg_types.hxx>
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
SG_USING_STD(vector);
#define ARRAY_SIZE_1 1201 #define ARRAY_SIZE_1 1201

6
src/Lib/Array/testarray.cxx
View file

@ -1,11 +1,11 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include STL_IOSTREAM #include <iostream>
#include "array.hxx" #include "array.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
int main( int argc, char **argv ) { int main( int argc, char **argv ) {
double lon, lat; double lon, lat;

6
src/Lib/DEM/dem.cxx
View file

@ -33,7 +33,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include STL_IOSTREAM #include <iostream>
#ifdef HAVE_SYS_STAT_H #ifdef HAVE_SYS_STAT_H
# include <sys/stat.h> // stat() # include <sys/stat.h> // stat()
@ -59,8 +59,8 @@
#include "dem.hxx" #include "dem.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
TGDem::TGDem() : TGDem::TGDem() :

2
src/Lib/DEM/dem.hxx
View file

@ -38,7 +38,7 @@
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
#include STL_STRING #include <string>
#define DEM_SIZE 1200 #define DEM_SIZE 1200
#define DEM_SIZE_1 1201 #define DEM_SIZE_1 1201

5
src/Lib/Geometry/contour_tree.hxx
View file

@ -35,13 +35,10 @@
#include <vector> #include <vector>
SG_USING_STD(vector);
// forward declaration // forward declaration
class TGContourNode; class TGContourNode;
typedef vector < TGContourNode * > contour_kids; typedef std::vector < TGContourNode * > contour_kids;
typedef contour_kids::iterator contour_kids_iterator; typedef contour_kids::iterator contour_kids_iterator;
typedef contour_kids::const_iterator const_contour_kids_iterator; typedef contour_kids::const_iterator const_contour_kids_iterator;

3
src/Lib/Geometry/line.hxx
View file

@ -15,7 +15,6 @@
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include <vector> #include <vector>
SG_USING_STD(vector);
#include "rectangle.hxx" #include "rectangle.hxx"
@ -85,7 +84,7 @@ public:
virtual Rectangle getBounds () const; virtual Rectangle getBounds () const;
private: private:
vector<Point3D> _points; std::vector<Point3D> _points;
}; };
}; };

10
src/Lib/Geometry/poly_support.cxx
View file

@ -50,11 +50,11 @@ extern "C" {
#include "trinodes.hxx" #include "trinodes.hxx"
#include "trisegs.hxx" #include "trisegs.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(sort); using std::sort;
SG_USING_STD(copy); using std::copy;
SG_USING_STD(ostream_iterator); using std::ostream_iterator;
// Given a line segment specified by two endpoints p1 and p2, return // Given a line segment specified by two endpoints p1 and p2, return
// the slope of the line. // the slope of the line.

6
src/Lib/Geometry/trisegs.cxx
View file

@ -24,14 +24,14 @@
#include <simgear/constants.h> #include <simgear/constants.h>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include STL_IOSTREAM #include <iostream>
#include "trinodes.hxx" #include "trinodes.hxx"
#include "trisegs.hxx" #include "trisegs.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
// Constructor // Constructor

5
src/Lib/Geometry/trisegs.hxx
View file

@ -36,9 +36,6 @@
#include "trinodes.hxx" #include "trinodes.hxx"
SG_USING_STD(vector);
// a segment is two integer pointers into the node list // a segment is two integer pointers into the node list
class TGTriSeg { class TGTriSeg {
int n1, n2; // indices into point list int n1, n2; // indices into point list
@ -75,7 +72,7 @@ inline bool operator == (const TGTriSeg& a, const TGTriSeg& b)
} }
typedef vector < TGTriSeg > triseg_list; typedef std::vector < TGTriSeg > triseg_list;
typedef triseg_list::iterator triseg_list_iterator; typedef triseg_list::iterator triseg_list_iterator;
typedef triseg_list::const_iterator const_triseg_list_iterator; typedef triseg_list::const_iterator const_triseg_list_iterator;

5
src/Lib/Geometry/util.hxx
View file

@ -15,7 +15,6 @@
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
#include <string> #include <string>
SG_USING_STD(string);
#include <Polygon/polygon.hxx> #include <Polygon/polygon.hxx>
@ -109,7 +108,7 @@ Rectangle makeBounds (const TGPolygon &polygon);
* @param s The string. * @param s The string.
* @return A rectangle containing the bounds. * @return A rectangle containing the bounds.
*/ */
Rectangle parseChunk (const string &s, double delta); Rectangle parseChunk (const std::string &s, double delta);
/** /**
@ -118,7 +117,7 @@ Rectangle parseChunk (const string &s, double delta);
* @param s The string. * @param s The string.
* @return A rectangle containing the bounds. * @return A rectangle containing the bounds.
*/ */
Rectangle parseTile (const string &s); Rectangle parseTile (const std::string &s);
}; // namespace tg }; // namespace tg

6
src/Lib/HGT/hgt.cxx
View file

@ -28,7 +28,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <stdlib.h> // atof() #include <stdlib.h> // atof()
#include STL_IOSTREAM #include <iostream>
#ifdef SG_HAVE_STD_INCLUDES #ifdef SG_HAVE_STD_INCLUDES
# include <cerrno> # include <cerrno>
@ -45,8 +45,8 @@
#include "hgt.hxx" #include "hgt.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
TGHgt::TGHgt( int _res ) { TGHgt::TGHgt( int _res ) {

10
src/Lib/HGT/hgt.hxx
View file

@ -32,13 +32,11 @@
#include <zlib.h> #include <zlib.h>
#include STL_STRING #include <string>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/misc/sg_path.hxx> #include <simgear/misc/sg_path.hxx>
SG_USING_STD(string);
#define MAX_HGT_SIZE 3601 #define MAX_HGT_SIZE 3601
@ -65,7 +63,7 @@ private:
int hgt_resolution; int hgt_resolution;
bool remove_tmp_file; bool remove_tmp_file;
string remove_file_name; std::string remove_file_name;
public: public:
@ -89,10 +87,10 @@ public:
// write out the area of data covered by the specified bucket. // write out the area of data covered by the specified bucket.
// Data is written out column by column starting at the lower left // Data is written out column by column starting at the lower left
// hand corner. // hand corner.
bool write_area( const string& root, SGBucket& b ); bool write_area( const std::string& root, SGBucket& b );
// write the entire area out in a simple ascii format // write the entire area out in a simple ascii format
bool write_whole_ascii( const string& file ); bool write_whole_ascii( const std::string& file );
// Informational methods // Informational methods
inline double get_originx() const { return originx; } inline double get_originx() const { return originx; }

6
src/Lib/Optimize/genfans.cxx
View file

@ -23,12 +23,12 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include "genfans.hxx" #include "genfans.hxx"
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( endl ); using std:: endl ;
// make sure the list is expanded at least to hold "n" and then push // make sure the list is expanded at least to hold "n" and then push

5
src/Lib/Optimize/genfans.hxx
View file

@ -38,10 +38,7 @@
#include <Triangulate/trieles.hxx> #include <Triangulate/trieles.hxx>
SG_USING_STD(vector); typedef std::vector < int_list > opt_list;
typedef vector < int_list > opt_list;
typedef opt_list::iterator opt_list_iterator; typedef opt_list::iterator opt_list_iterator;
typedef opt_list::const_iterator const_opt_list_iterator; typedef opt_list::const_iterator const_opt_list_iterator;

5
src/Lib/Optimize/genstrips.hxx
View file

@ -39,10 +39,7 @@
#include <Triangulate/trieles.hxx> #include <Triangulate/trieles.hxx>
SG_USING_STD(vector); typedef std::vector < int_list > opt_list;
typedef vector < int_list > opt_list;
typedef opt_list::iterator opt_list_iterator; typedef opt_list::iterator opt_list_iterator;
typedef opt_list::const_iterator const_opt_list_iterator; typedef opt_list::const_iterator const_opt_list_iterator;

6
src/Lib/Output/output.cxx
View file

@ -33,7 +33,7 @@
#include <zlib.h> #include <zlib.h>
#include <list> #include <list>
#include STL_STRING #include <string>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
@ -45,8 +45,8 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( endl ); using std:: endl ;
void write_polygon( const TGPolygon& poly, const string& base ) { void write_polygon( const TGPolygon& poly, const string& base ) {

2
src/Lib/Output/output.hxx
View file

@ -37,7 +37,7 @@
#include <time.h> #include <time.h>
#include <list> #include <list>
#include STL_STRING #include <string>
#include <simgear/math/sg_types.hxx> #include <simgear/math/sg_types.hxx>

8
src/Lib/Polygon/chop-bin.cxx
View file

@ -29,11 +29,11 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>

5
src/Lib/Polygon/index.cxx
View file

@ -23,16 +23,17 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
#include STL_STRING #include <string>
#include <stdio.h> #include <stdio.h>
#include "index.hxx" #include "index.hxx"
using std::string;
static long int poly_index; static long int poly_index;
static string poly_path; static string poly_path;
// initialize the unique polygon index counter stored in path // initialize the unique polygon index counter stored in path
bool poly_index_init( string path ) { bool poly_index_init( string path ) {
poly_path = path; poly_path = path;

7
src/Lib/Polygon/index.hxx
View file

@ -27,13 +27,10 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
SG_USING_STD(string);
// initialize the unique polygon index counter stored in path // initialize the unique polygon index counter stored in path
bool poly_index_init( string path ); bool poly_index_init( std::string path );
// increment the persistant counter and return the next poly_index // increment the persistant counter and return the next poly_index
long int poly_index_next(); long int poly_index_next();

10
src/Lib/Polygon/names.hxx
View file

@ -27,21 +27,19 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
SG_USING_STD(string); inline static bool is_ocean_area( const std::string &area )
inline static bool is_ocean_area( const string &area )
{ {
return area=="Ocean" || area=="Bay Estuary or Ocean"; return area=="Ocean" || area=="Bay Estuary or Ocean";
} }
inline static bool is_void_area( const string &area ) inline static bool is_void_area( const std::string &area )
{ {
return area=="Void Area"; return area=="Void Area";
} }
inline static bool is_null_area( const string& area ) inline static bool is_null_area( const std::string& area )
{ {
return area=="Null"; return area=="Null";
} }

2
src/Lib/Polygon/polygon.cxx
View file

@ -35,7 +35,7 @@ extern "C" {
#include <simgear/math/sg_geodesy.hxx> #include <simgear/math/sg_geodesy.hxx>
#include <simgear/structure/exception.hxx> #include <simgear/structure/exception.hxx>
SG_USING_STD(endl); using std::endl;
#include <Geometry/trinodes.hxx> #include <Geometry/trinodes.hxx>
#include <poly2tri/interface.h> #include <poly2tri/interface.h>

19
src/Lib/Polygon/polygon.hxx
View file

@ -33,21 +33,16 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <simgear/math/sg_types.hxx> #include <simgear/math/sg_types.hxx>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <vector> #include <vector>
#include "point2d.hxx" #include "point2d.hxx"
SG_USING_STD(ostream);
SG_USING_STD(string);
SG_USING_STD(vector);
#define FG_MAX_VERTICES 1500000 #define FG_MAX_VERTICES 1500000
typedef vector < point_list > polytype; typedef std::vector < point_list > polytype;
typedef polytype::iterator polytype_iterator; typedef polytype::iterator polytype_iterator;
typedef polytype::const_iterator const_polytype_iterator; typedef polytype::const_iterator const_polytype_iterator;
@ -182,14 +177,14 @@ public:
bool is_inside( int a, int b ) const; bool is_inside( int a, int b ) const;
// output // output
void write( const string& file ) const; void write( const std::string& file ) const;
// output // output
void write_contour( const int contour, const string& file ) const; void write_contour( const int contour, const std::string& file ) const;
}; };
typedef vector < TGPolygon > poly_list; typedef std::vector < TGPolygon > poly_list;
typedef poly_list::iterator poly_list_iterator; typedef poly_list::iterator poly_list_iterator;
typedef poly_list::const_iterator const_poly_list_iterator; typedef poly_list::const_iterator const_poly_list_iterator;
@ -234,7 +229,7 @@ TGPolygon tgPolygonXor( const TGPolygon& subject, const TGPolygon& clip );
TGPolygon tgPolygonUnion( const TGPolygon& subject, const TGPolygon& clip ); TGPolygon tgPolygonUnion( const TGPolygon& subject, const TGPolygon& clip );
// Output // Output
ostream &operator<< (ostream &output, const TGPolygon &poly); std::ostream &operator<< (std::ostream &output, const TGPolygon &poly);
#endif // _POLYGON_HXX #endif // _POLYGON_HXX

18
src/Lib/Polygon/superpoly.hxx
View file

@ -43,21 +43,17 @@
#include "polygon.hxx" #include "polygon.hxx"
SG_USING_STD(string);
SG_USING_STD(vector);
class TGSuperPoly { class TGSuperPoly {
private: private:
string material; // material/texture name std::string material; // material/texture name
TGPolygon poly; // master polygon TGPolygon poly; // master polygon
TGPolygon normals; // corresponding normals TGPolygon normals; // corresponding normals
TGPolygon texcoords; // corresponding texture coordinates TGPolygon texcoords; // corresponding texture coordinates
TGPolygon tris; // triangulation TGPolygon tris; // triangulation
GLenum tri_mode; // GL_TRIANGLE, GL_FAN, GL_TRISTRIP, etc. GLenum tri_mode; // GL_TRIANGLE, GL_FAN, GL_TRISTRIP, etc.
string flag; // For various potential record keeping needs std::string flag; // For various potential record keeping needs
public: public:
@ -65,8 +61,8 @@ public:
TGSuperPoly( void ); TGSuperPoly( void );
~TGSuperPoly( void ); ~TGSuperPoly( void );
inline string get_material() const { return material; } inline std::string get_material() const { return material; }
inline void set_material( const string &m ) { material = m; } inline void set_material( const std::string &m ) { material = m; }
inline TGPolygon get_poly() const { return poly; } inline TGPolygon get_poly() const { return poly; }
inline void set_poly( const TGPolygon &p ) { poly = p; } inline void set_poly( const TGPolygon &p ) { poly = p; }
@ -83,8 +79,8 @@ public:
inline GLenum get_tri_mode() const { return tri_mode; } inline GLenum get_tri_mode() const { return tri_mode; }
inline void set_tri_mode( const GLenum &m ) { tri_mode = m; } inline void set_tri_mode( const GLenum &m ) { tri_mode = m; }
inline string get_flag() const { return flag; } inline std::string get_flag() const { return flag; }
inline void set_flag( const string f ) { flag = f; } inline void set_flag( const std::string f ) { flag = f; }
// erase the polygon // erase the polygon
void erase(); void erase();
@ -92,7 +88,7 @@ public:
}; };
typedef vector < TGSuperPoly > superpoly_list; typedef std::vector < TGSuperPoly > superpoly_list;
typedef superpoly_list::iterator superpoly_list_iterator; typedef superpoly_list::iterator superpoly_list_iterator;
typedef superpoly_list::const_iterator const_superpoly_list_iterator; typedef superpoly_list::const_iterator const_superpoly_list_iterator;

18
src/Lib/e00/e00.cxx
View file

@ -6,20 +6,20 @@
#include <vector> #include <vector>
#include <map> #include <map>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <cctype> #include <cctype>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
SG_USING_STD(vector); using std::vector;
SG_USING_STD(map); using std::map;
SG_USING_STD(string); using std::string;
SG_USING_STD(istream); using std::istream;
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(getline); using std::getline;
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////

75
src/Lib/e00/e00.hxx
View file

@ -6,23 +6,18 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include <vector> #include <vector>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
SG_USING_STD(vector);
SG_USING_STD(string);
SG_USING_STD(istream);
// An exception reading an E00 file. // An exception reading an E00 file.
class E00Exception class E00Exception
{ {
public: public:
E00Exception (const string &message) : _message(message) {} E00Exception (const std::string &message) : _message(message) {}
virtual const string &getMessage () const { return _message; } virtual const std::string &getMessage () const { return _message; }
private: private:
string _message; std::string _message;
}; };
@ -61,7 +56,7 @@ public:
int leftPolygon; int leftPolygon;
int rightPolygon; int rightPolygon;
int numberOfCoordinates; int numberOfCoordinates;
vector<Coord> coordinates; std::vector<Coord> coordinates;
bool in_polygon; bool in_polygon;
}; };
@ -73,7 +68,7 @@ public:
virtual ~CNT () {} virtual ~CNT () {}
int numLabels; int numLabels;
Coord centroid; Coord centroid;
vector<int> labels; std::vector<int> labels;
}; };
@ -95,7 +90,7 @@ public:
struct LOG struct LOG
{ {
virtual ~LOG () {} virtual ~LOG () {}
vector<string> lines; std::vector<std::string> lines;
}; };
@ -113,7 +108,7 @@ public:
int numArcs; int numArcs;
Coord min; Coord min;
Coord max; Coord max;
vector<ARCref> arcs; std::vector<ARCref> arcs;
}; };
@ -122,7 +117,7 @@ public:
struct PRJ struct PRJ
{ {
virtual ~PRJ () {} virtual ~PRJ () {}
vector<string> lines; std::vector<std::string> lines;
}; };
@ -144,33 +139,33 @@ public:
virtual ~IFO () {} virtual ~IFO () {}
struct ItemDef struct ItemDef
{ {
string itemName; std::string itemName;
int itemWidth; // followed by -1 int itemWidth; // followed by -1
int itemStartPos; // followed by 4-1 int itemStartPos; // followed by 4-1
int itemOutputFormat[2]; int itemOutputFormat[2];
string itemType; std::string itemType;
// -1 // -1
// -1-1 // -1-1
string seqId; std::string seqId;
}; };
typedef vector<string> Entry; typedef std::vector<std::string> Entry;
string fileName; std::string fileName;
string isArcInfo; std::string isArcInfo;
int numItems; int numItems;
int altNumItems; int altNumItems;
int dataRecordLength; int dataRecordLength;
int numDataRecords; int numDataRecords;
vector<ItemDef> defs; std::vector<ItemDef> defs;
vector<Entry> entries; std::vector<Entry> entries;
}; };
E00 (); E00 ();
virtual ~E00 (); virtual ~E00 ();
virtual void readE00 (istream &input); virtual void readE00 (std::istream &input);
virtual string getPathName () const { return pathName; } virtual std::string getPathName () const { return pathName; }
virtual int nPoints () const { return lab_section.size(); } virtual int nPoints () const { return lab_section.size(); }
virtual int nLines () const { return arc_section.size(); } virtual int nLines () const { return arc_section.size(); }
@ -181,28 +176,28 @@ public:
virtual const LAB &getLAB (int i) const { return lab_section[i-1]; } virtual const LAB &getLAB (int i) const { return lab_section[i-1]; }
virtual const PAL &getPAL (int i) const { return pal_section[i-1]; } virtual const PAL &getPAL (int i) const { return pal_section[i-1]; }
virtual const IFO &getIFO (int i) const { return ifo_section[i-1]; } virtual const IFO &getIFO (int i) const { return ifo_section[i-1]; }
virtual const IFO * getIFO (const string &name) const; virtual const IFO * getIFO (const std::string &name) const;
virtual const string * getIFOItem (const string &fileName, int entry, virtual const std::string * getIFOItem (const std::string &fileName, int entry,
const string &itemName) const; const std::string &itemName) const;
virtual const string * getIFOItemType (const string &fileName, virtual const std::string * getIFOItemType (const std::string &fileName,
const string &itemName) const; const std::string &itemName) const;
private: private:
virtual ARC &_getARC (int i) { return arc_section[i-1]; } virtual ARC &_getARC (int i) { return arc_section[i-1]; }
string pathName; std::string pathName;
vector<ARC> arc_section; std::vector<ARC> arc_section;
vector<CNT> cnt_section; std::vector<CNT> cnt_section;
vector<LAB> lab_section; std::vector<LAB> lab_section;
vector<LOG> log_section; std::vector<LOG> log_section;
vector<PAL> pal_section; std::vector<PAL> pal_section;
vector<PRJ> prj_section; std::vector<PRJ> prj_section;
vector<TOL> tol_section; std::vector<TOL> tol_section;
vector<IFO> ifo_section; std::vector<IFO> ifo_section;
mutable istream * _input; mutable std::istream * _input;
void postProcess (); void postProcess ();

6
src/Lib/e00/teste00.cxx
View file

@ -9,9 +9,9 @@
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
#include "e00.hxx" #include "e00.hxx"
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
int main (int ac, const char ** av) int main (int ac, const char ** av)
{ {

6
src/Lib/landcover/landcover.cxx
View file

@ -5,13 +5,13 @@
// Use at your own risk. // Use at your own risk.
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include "landcover.hxx" #include "landcover.hxx"
SG_USING_STD(ifstream); using std::ifstream;
SG_USING_STD(string); using std::string;
LandCover::LandCover( const string &filename ) LandCover::LandCover( const string &filename )
{ {

12
src/Lib/landcover/landcover.hxx
View file

@ -9,12 +9,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_FSTREAM #include <fstream>
SG_USING_STD(ifstream);
SG_USING_STD(string);
/** /**
* Query class for the USGS worldwide 30 arcsec land-cover image. * Query class for the USGS worldwide 30 arcsec land-cover image.
@ -65,7 +61,7 @@ class LandCover {
public: public:
LandCover( const string &filename ); LandCover( const std::string &filename );
virtual ~LandCover (); virtual ~LandCover ();
virtual int getValue (long x, long y) const; virtual int getValue (long x, long y) const;
@ -73,7 +69,7 @@ public:
virtual const char *getDescUSGS (int value) const; virtual const char *getDescUSGS (int value) const;
private: private:
mutable ifstream * _input; mutable std::ifstream * _input;
long WIDTH; long WIDTH;
long HEIGHT; long HEIGHT;
}; };

12
src/Lib/landcover/test-landcover.cxx
View file

@ -7,15 +7,15 @@
#include <stdlib.h> #include <stdlib.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include "landcover.hxx" #include "landcover.hxx"
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
int int
main (int ac, const char * av[]) main (int ac, const char * av[])

10
src/Lib/vpf/table.cxx
View file

@ -3,16 +3,16 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_FSTREAM #include <fstream>
#include <simgear/misc/zfstream.hxx> // ios_binary #include <simgear/misc/zfstream.hxx> // ios_binary
#include <stdlib.h> #include <stdlib.h>
SG_USING_STD(string); using std::string;
SG_USING_STD(ifstream); using std::ifstream;
SG_USING_STD(istream); using std::istream;
#include "vpfbase.hxx" #include "vpfbase.hxx"
#include "table.hxx" #include "table.hxx"

14
src/Lib/vpf/vpf-topology.cxx
View file

@ -3,16 +3,16 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <stdlib.h> #include <stdlib.h>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(ostream); using std::ostream;
SG_USING_STD(string); using std::string;
#include "vpf.hxx" #include "vpf.hxx"

10
src/Prep/DemChop/demchop.cxx
View file

@ -27,8 +27,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -41,9 +41,9 @@
#include "point2d.hxx" #include "point2d.hxx"
SG_USING_STD(endl); using std::endl;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(string); using std::string;
int main(int argc, char **argv) { int main(int argc, char **argv) {

10
src/Prep/DemChop/fillvoids.cxx
View file

@ -26,8 +26,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -35,9 +35,9 @@
#include <Array/array.hxx> #include <Array/array.hxx>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
int main(int argc, char **argv) { int main(int argc, char **argv) {

10
src/Prep/DemChop/hgtchop.cxx
View file

@ -27,8 +27,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -40,9 +40,9 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
int main(int argc, char **argv) { int main(int argc, char **argv) {

10
src/Prep/DemChop/testassem.cxx
View file

@ -27,8 +27,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -40,9 +40,9 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
int data[3601][3601]; int data[3601][3601];

8
src/Prep/DemInfo/deminfo.cxx
View file

@ -23,8 +23,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -32,8 +32,8 @@
#include <DEM/dem.hxx> #include <DEM/dem.hxx>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(string); using std::string;
// static float dem_data[DEM_SIZE_1][DEM_SIZE_1]; // static float dem_data[DEM_SIZE_1][DEM_SIZE_1];

14
src/Prep/E00Lines/main.cxx
View file

@ -33,15 +33,15 @@
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <vector> #include <vector>
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
SG_USING_STD(vector); using std::vector;
#include <Geometry/rectangle.hxx> #include <Geometry/rectangle.hxx>
#include <Geometry/util.hxx> #include <Geometry/util.hxx>

10
src/Prep/GSHHS/debug.cxx
View file

@ -29,8 +29,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <zlib.h> #include <zlib.h>
@ -47,9 +47,9 @@
# define FLIP # define FLIP
#endif #endif
SG_USING_STD(cout); using std::cout;
SG_USING_STD(cin); using std::cin;
SG_USING_STD(endl); using std::endl;
// write result to unique file name // write result to unique file name
void write_result( const TGPolygon& result ) { void write_result( const TGPolygon& result ) {

10
src/Prep/GSHHS/gshhs_split.cxx
View file

@ -26,8 +26,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -39,9 +39,9 @@
#include "gshhs_split.hxx" #include "gshhs_split.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
// process shape front end ... split shape into lon = -180 ... 180, // process shape front end ... split shape into lon = -180 ... 180,

10
src/Prep/GSHHS/main.cxx
View file

@ -29,8 +29,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <zlib.h> #include <zlib.h>
@ -46,9 +46,9 @@
#include "gshhs.h" #include "gshhs.h"
#include "gshhs_split.hxx" #include "gshhs_split.hxx"
SG_USING_STD( string ); using std:: string ;
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( endl ); using std:: endl ;
// hackity, hackity, hack ... cough cough // hackity, hackity, hack ... cough cough
#ifdef i386 #ifdef i386

2
src/Prep/MergerClipper/merger.cxx
View file

@ -39,7 +39,7 @@
#include "merger.hxx" #include "merger.hxx"
SG_USING_STD(cout); using std::cout;
// Constructor // Constructor
FGMerger::FGMerger( void ) { FGMerger::FGMerger( void ) {

10
src/Prep/MergerClipper/merger.hxx
View file

@ -37,11 +37,7 @@
#include <Polygon/polygon.hxx> #include <Polygon/polygon.hxx>
#include <Polygon/names.hxx> #include <Polygon/names.hxx>
#include STL_STRING #include <string>
#include <vector>
SG_USING_STD(string);
SG_USING_STD(vector);
#define FG_MAX_AREA_TYPES 128 // FIXME: also defined in clipper.hxx #define FG_MAX_AREA_TYPES 128 // FIXME: also defined in clipper.hxx
@ -70,14 +66,14 @@ public:
// Initialize Clipper (allocate and/or connect structures) // Initialize Clipper (allocate and/or connect structures)
bool init(); bool init();
bool load_polys(const string& path, FGPolyList& clipped); bool load_polys(const std::string& path, FGPolyList& clipped);
// Merge all polygons of the given area // Merge all polygons of the given area
void merge(FGPolyList& clipped); void merge(FGPolyList& clipped);
// Clip all merged polygons with the land mass one // Clip all merged polygons with the land mass one
void clip(FGPolyList& subject, FGPolyList& clip); void clip(FGPolyList& subject, FGPolyList& clip);
void write(FGPolyList& subject, string& file); void write(FGPolyList& subject, std::string& file);
inline FGPolyList get_polys_clipped() const { return polys_subject; } inline FGPolyList get_polys_clipped() const { return polys_subject; }

4
src/Prep/MergerClipper/testmerger.cxx
View file

@ -33,8 +33,8 @@
#include "merger.hxx" #include "merger.hxx"
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
int main( int argc, char **argv ) { int main( int argc, char **argv ) {
point2d global_min, global_max; point2d global_min, global_max;

8
src/Prep/OGRDecode/ogr-decode.cxx
View file

@ -26,7 +26,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include <map> #include <map>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -45,9 +45,9 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( string ); using std:: string ;
SG_USING_STD( map ); using std:: map ;
int line_width=50; int line_width=50;
string line_width_col; string line_width_col;

4
src/Prep/Photo/findcorners.cxx
View file

@ -8,8 +8,8 @@
#include <plib/sg.h> #include <plib/sg.h>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
#include <simgear/math/sg_geodesy.hxx> #include <simgear/math/sg_geodesy.hxx>

10
src/Prep/Photo/photo.cxx
View file

@ -29,8 +29,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <simgear/bucket/newbucket.hxx> #include <simgear/bucket/newbucket.hxx>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -44,9 +44,9 @@
#include <Polygon/index.hxx> #include <Polygon/index.hxx>
#include <Polygon/polygon.hxx> #include <Polygon/polygon.hxx>
SG_USING_STD(string); using std::string;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
const int MAX_XDIV = 16; const int MAX_XDIV = 16;

6
src/Prep/Photo/wgs84offset.cxx
View file

@ -2,15 +2,15 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <simgear/math/sg_geodesy.hxx> #include <simgear/math/sg_geodesy.hxx>
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
int main( int argc, char **argv ) { int main( int argc, char **argv ) {

6
src/Prep/ShapeFile/noaa-decode.cxx
View file

@ -25,7 +25,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -38,8 +38,8 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( string ); using std:: string ;
// return the type of the shapefile record // return the type of the shapefile record
std::string get_shapefile_type(DBFHandle& hDBF, int rec) { std::string get_shapefile_type(DBFHandle& hDBF, int rec) {

12
src/Prep/ShapeFile/shape-decode.cxx
View file

@ -29,8 +29,8 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include STL_IOSTREAM #include <iostream>
#include <map> #include <map>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
@ -49,10 +49,10 @@
# include <Win32/mkdir.hpp> # include <Win32/mkdir.hpp>
#endif #endif
SG_USING_STD( cout ); using std:: cout ;
SG_USING_STD( endl ); using std:: endl ;
SG_USING_STD( string ); using std:: string ;
SG_USING_STD( map ); using std:: map ;
map<string,string> area_code_map; map<string,string> area_code_map;
bool use_area_code_map = false; bool use_area_code_map = false;

14
src/Prep/TGVPF/tgvpf.cxx
View file

@ -34,15 +34,15 @@
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
#include <simgear/timing/timestamp.hxx> #include <simgear/timing/timestamp.hxx>
#include STL_IOSTREAM #include <iostream>
#include STL_STRING #include <string>
#include <vector> #include <vector>
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(string); using std::string;
SG_USING_STD(vector); using std::vector;
#include <Geometry/line.hxx> #include <Geometry/line.hxx>
#include <Geometry/util.hxx> #include <Geometry/util.hxx>

2
src/Prep/Terra/Mask.h
View file

@ -3,7 +3,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_IOSTREAM #include <iostream>
using std::istream; using std::istream;

16
src/Prep/Terra/output.cc
View file

@ -1,17 +1,17 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_FSTREAM #include <fstream>
#include <streambuf> #include <streambuf>
#include "terra.h" #include "terra.h"
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(cout); using std::cout;
SG_USING_STD(endl); using std::endl;
SG_USING_STD(istream); using std::istream;
SG_USING_STD(ostream); using std::ostream;
SG_USING_STD(ofstream); using std::ofstream;
SG_USING_STD(streampos); using std::streampos;
namespace Terra { namespace Terra {

8
src/Prep/UserDef/tguserdef.cxx
View file

@ -13,14 +13,14 @@
#include <Polygon/index.hxx> #include <Polygon/index.hxx>
#include <Polygon/polygon.hxx> #include <Polygon/polygon.hxx>
#include STL_IOSTREAM #include <iostream>
#include <stdlib.h> #include <stdlib.h>
#include <vector> #include <vector>
SG_USING_STD(vector); using std::vector;
SG_USING_STD(cerr); using std::cerr;
SG_USING_STD(endl); using std::endl;
static string prog_name; static string prog_name;
static string work_dir = "."; static string work_dir = ".";

2
src/Utils/poly2ogr/poly2ogr.cxx
View file

@ -22,7 +22,7 @@
#include <simgear/compiler.h> #include <simgear/compiler.h>
#include STL_STRING #include <string>
#include <map> #include <map>
#include <sys/types.h> #include <sys/types.h>