BindingGenerator: remove "using namespace" from headers

Source/Tools/BindingGenerator/ASClassBinder.cpp

@@ -35,6 +35,9 @@
 #include <unordered_map>
 #include <unordered_set>
 
+using namespace std;
+using namespace pugi;
+
 namespace ASBindingGenerator
 {
 

Source/Tools/BindingGenerator/ASEnumBinder.cpp

@@ -29,6 +29,8 @@
 
 #include <cassert>
 
+using namespace std;
+
 namespace ASBindingGenerator
 {
 

Source/Tools/BindingGenerator/ASGlobalFunctionBinder.cpp

@@ -31,6 +31,8 @@
 #include <map>
 #include <regex>
 
+using namespace std;
+
 namespace ASBindingGenerator
 {
 

Source/Tools/BindingGenerator/ASGlobalVariableBinder.cpp

@@ -27,6 +27,8 @@
 #include "XmlAnalyzer.h"
 #include "XmlSourceData.h"
 
+using namespace std;
+
 namespace ASBindingGenerator
 {
 

Source/Tools/BindingGenerator/ASResult.cpp

@@ -29,6 +29,8 @@
 #include <unordered_map>
 #include <memory>
 
+using namespace std;
+
 extern string _sourceDir;
 
 namespace ASBindingGenerator

Source/Tools/BindingGenerator/ASResult.h

@@ -27,8 +27,6 @@
 #include <string>
 #include <vector>
 
-using namespace std;
-
 namespace ASBindingGenerator
 {
 
@@ -36,14 +34,14 @@ class ASGeneratedFile_Base
 {
 protected:
     // Result file path
-    string outputFilePath_;
+    std::string outputFilePath_;
 
 public:
     // Wrappers
-    stringstream glue_;
+    std::stringstream glue_;
 
     // Registration function body
-    stringstream reg_;
+    std::stringstream reg_;
 
     // Write result to file
     virtual void Save() {};
@@ -53,10 +51,10 @@ class ASGeneratedFile_WithRegistrationFunction : public ASGeneratedFile_Base
 {
 protected:
     // Registration function name
-    string functionName_;
+    std::string functionName_;
 
 public:
-    ASGeneratedFile_WithRegistrationFunction(const string& outputFilePath, const string& functionName);
+    ASGeneratedFile_WithRegistrationFunction(const std::string& outputFilePath, const std::string& functionName);
 };
 
 class ASGeneratedFile_Members : public ASGeneratedFile_WithRegistrationFunction
@@ -71,7 +69,7 @@ class ASGeneratedFile_Templates : public ASGeneratedFile_Base
 {
 
 public:
-    ASGeneratedFile_Templates(const string& outputFilePath);
+    ASGeneratedFile_Templates(const std::string& outputFilePath);
 
     // Write result to file
     void Save() override;
@@ -79,11 +77,11 @@ public:
 
 struct ProcessedEnum
 {
-    string name_; // Used for sorting
-    string comment_; // Location
-    vector<string> glue_; // Can be empty
-    string insideDefine_; // Can be empty
-    vector<string> registration_; // Or warning message
+    std::string name_; // Used for sorting
+    std::string comment_; // Location
+    std::vector<std::string> glue_; // Can be empty
+    std::string insideDefine_; // Can be empty
+    std::vector<std::string> registration_; // Or warning message
 
     // Used for sorting
     bool operator <(const ProcessedEnum& rhs) const;
@@ -91,11 +89,11 @@ struct ProcessedEnum
 
 struct ProcessedGlobalFunction
 {
-    string name_; // Used for sorting
-    string comment_; // Location
-    string glue_; // Can be empty
-    string insideDefine_; // Can be empty
-    string registration_; // Or warning message
+    std::string name_; // Used for sorting
+    std::string comment_; // Location
+    std::string glue_; // Can be empty
+    std::string insideDefine_; // Can be empty
+    std::string registration_; // Or warning message
 
     // Used for sorting
     bool operator <(const ProcessedGlobalFunction& rhs) const;
@@ -103,10 +101,10 @@ struct ProcessedGlobalFunction
 
 struct ProcessedGlobalVariable
 {
-    string name_; // Used for sorting
-    string comment_; // Location
-    string insideDefine_; // Can be empty
-    string registration_; // Or warning message
+    std::string name_; // Used for sorting
+    std::string comment_; // Location
+    std::string insideDefine_; // Can be empty
+    std::string registration_; // Or warning message
 
     // Used for sorting
     bool operator <(const ProcessedGlobalVariable& rhs) const;
@@ -114,97 +112,97 @@ struct ProcessedGlobalVariable
 
 struct Registration
 {
-    string comment_;
-    string glue_;
-    vector<string> registration_;
+    std::string comment_;
+    std::string glue_;
+    std::vector<std::string> registration_;
 };
 
 struct SpecialMethodRegistration
 {
-    string comment_; // C++ declaration / location for default constructor
-    string glue_;
-    string registration_; // Or warning message
+    std::string comment_; // C++ declaration / location for default constructor
+    std::string glue_;
+    std::string registration_; // Or warning message
 };
 
 struct RegisterObjectMethodArgs
 {
-    vector<string> asDeclarations_; // String
-    string funcPointer_;            // asSFuncPtr
-    string callConv_;               // asDWORD
+    std::vector<std::string> asDeclarations_; // String
+    std::string funcPointer_;            // asSFuncPtr
+    std::string callConv_;               // asDWORD
 };
 
 struct MethodRegistration
 {
-    string name_; // Used for sorting
-    string cppDeclaration_;
-    string glue_;
+    std::string name_; // Used for sorting
+    std::string cppDeclaration_;
+    std::string glue_;
     RegisterObjectMethodArgs registration_;
 };
 
 struct RegisterGlobalFunctionArgs
 {
-    vector<string> asDeclarations_; // String
-    string funcPointer_;            // asSFuncPtr
-    string callConv_;               // asDWORD
+    std::vector<std::string> asDeclarations_; // String
+    std::string funcPointer_;            // asSFuncPtr
+    std::string callConv_;               // asDWORD
 };
 
 struct StaticMethodRegistration
 {
-    string name_; // Used for sorting
-    string cppDeclaration_;
-    string glue_;
+    std::string name_; // Used for sorting
+    std::string cppDeclaration_;
+    std::string glue_;
     RegisterGlobalFunctionArgs registration_;
 };
 
 struct RegisterObjectPropertyArgs
 {
-    vector<string> asDeclarations_; // String
-    string byteOffset_;             // int
+    std::vector<std::string> asDeclarations_; // String
+    std::string byteOffset_;             // int
 };
 
 struct FieldRegistration
 {
-    string name_; // Used for sorting
-    string cppDeclaration_;
+    std::string name_; // Used for sorting
+    std::string cppDeclaration_;
     RegisterObjectPropertyArgs registration_;
 };
 
 struct RegisterGlobalPropertyArgs
 {
-    vector<string> asDeclarations_; // String
-    string pointer_;                // void*
+    std::vector<std::string> asDeclarations_; // String
+    std::string pointer_;                // void*
 };
 
 struct StaticFieldRegistration
 {
-    string name_; // Used for sorting
-    string cppDeclaration_;
+    std::string name_; // Used for sorting
+    std::string cppDeclaration_;
     RegisterGlobalPropertyArgs registration_;
 };
 
 /*
 struct RegisterObjectBehaviourArgs
 {
-    string behaviour_;              // asEBehaviours
-    vector<string> asDeclarations_; // String
-    string funcPointer_;            // asSFuncPtr
-    string callConv_;               // asDWORD
+    std::string behaviour_;              // asEBehaviours
+    std::vector<std::string> asDeclarations_; // String
+    std::string funcPointer_;            // asSFuncPtr
+    std::string callConv_;               // asDWORD
 };
 
 struct BehaviorRegistration
 {
-    string name_; // Used for sorting
-    string cppDeclaration_;
-    //string glue_;
+    std::string name_; // Used for sorting
+    std::string cppDeclaration_;
+    //std::string glue_;
     RegisterObjectBehaviourArgs registration_;
 };
 */
 
 struct MemberRegistrationError
 {
-    string name_; // Used for sorting
-    string comment_; // C++ declaration / location
-    string message_;
+    std::string name_; // Used for sorting
+    std::string comment_; // C++ declaration / location
+    std::string message_;
 
     // Used for sorting
     bool operator <(const MemberRegistrationError& rhs) const;
@@ -212,80 +210,80 @@ struct MemberRegistrationError
 
 struct ProcessedClass
 {
-    string name_;
-    string dirName_;
-    string insideDefine_; // Can be empty
-    string comment_; // Class location
-    string objectTypeRegistration_; // engine->RegisterObjectType(...); or warning message
+    std::string name_;
+    std::string dirName_;
+    std::string insideDefine_; // Can be empty
+    std::string comment_; // Class location
+    std::string objectTypeRegistration_; // engine->RegisterObjectType(...); or warning message
     int inherianceDeep_ = 0; // Used for sorting
 
     // Used for sorting
     bool operator <(const ProcessedClass& rhs) const;
 
-    shared_ptr<SpecialMethodRegistration> defaultConstructor_;
-    vector<SpecialMethodRegistration> nonDefaultConstructors_;
+    std::shared_ptr<SpecialMethodRegistration> defaultConstructor_;
+    std::vector<SpecialMethodRegistration> nonDefaultConstructors_;
 
-    shared_ptr<SpecialMethodRegistration> destructor_;
+    std::shared_ptr<SpecialMethodRegistration> destructor_;
 
-    vector<MemberRegistrationError> unregisteredSpecialMethods_;
+    std::vector<MemberRegistrationError> unregisteredSpecialMethods_;
 
-    //vector<MethodRegistration> methods_;
+    //std::vector<MethodRegistration> methods_;
 
 
-    //vector<StaticMethodRegistration> staticMethods_;
-    //vector<MemberRegistrationError> unregisteredStaticMethods_;
+    //std::vector<StaticMethodRegistration> staticMethods_;
+    //std::vector<MemberRegistrationError> unregisteredStaticMethods_;
 
-    //vector<FieldRegistration> fields_;
-    //vector<MemberRegistrationError> unregisteredFields_;
+    //std::vector<FieldRegistration> fields_;
+    //std::vector<MemberRegistrationError> unregisteredFields_;
 
-    //vector<MethodRegistration> wrappedFields_;
+    //std::vector<MethodRegistration> wrappedFields_;
 
-    //vector<StaticFieldRegistration> staticFields_;
-    //vector<MemberRegistrationError> unregisteredStaticFields_;
+    //std::vector<StaticFieldRegistration> staticFields_;
+    //std::vector<MemberRegistrationError> unregisteredStaticFields_;
 
-    vector<string> additionalLines_;
+    std::vector<std::string> additionalLines_;
 
     bool noBind_ = false;
 
-    vector<string> baseClassNames_;
-    vector<string> subclassRegistrations_;
+    std::vector<std::string> baseClassNames_;
+    std::vector<std::string> subclassRegistrations_;
 
     // Base class members that were hidden in this class (c++ declarations)
-    /*vector<string> hiddenMethods_;
-    vector<string> hiddenStaticMethods_;
-    vector<string> hiddenFields_;
-    vector<string> hiddenStaticFields_;*/
-
-    vector<Registration> templateMethods_;
-    vector<MemberRegistrationError> unregisteredTemplateMethods_;
-    vector<Registration> personalMethods_;
-    vector<MemberRegistrationError> unregisteredPersonalMethods_;
-
-    vector<Registration> templateStaticMethods_;
-    vector<MemberRegistrationError> unregisteredTemplateStaticMethods_;
-    vector<Registration> personalStaticMethods_;
-    vector<MemberRegistrationError> unregisteredPersonalStaticMethods_;
+    /*std::vector<std::string> hiddenMethods_;
+    std::vector<std::string> hiddenStaticMethods_;
+    std::vector<std::string> hiddenFields_;
+    std::vector<std::string> hiddenStaticFields_;*/
+
+    std::vector<Registration> templateMethods_;
+    std::vector<MemberRegistrationError> unregisteredTemplateMethods_;
+    std::vector<Registration> personalMethods_;
+    std::vector<MemberRegistrationError> unregisteredPersonalMethods_;
+
+    std::vector<Registration> templateStaticMethods_;
+    std::vector<MemberRegistrationError> unregisteredTemplateStaticMethods_;
+    std::vector<Registration> personalStaticMethods_;
+    std::vector<MemberRegistrationError> unregisteredPersonalStaticMethods_;
     
-    vector<Registration> personalFields_;
-    vector<MemberRegistrationError> unregisteredPersonalFields_;
-    vector<Registration> templateFields_;
-    vector<MemberRegistrationError> unregisteredTemplateFields_;
-
-    vector<Registration> personalStaticFields_;
-    vector<MemberRegistrationError> unregisteredPersonalStaticFields_;
-    vector<Registration> templateStaticFields_;
-    vector<MemberRegistrationError> unregisteredTemplateStaticFields_;
+    std::vector<Registration> personalFields_;
+    std::vector<MemberRegistrationError> unregisteredPersonalFields_;
+    std::vector<Registration> templateFields_;
+    std::vector<MemberRegistrationError> unregisteredTemplateFields_;
+
+    std::vector<Registration> personalStaticFields_;
+    std::vector<MemberRegistrationError> unregisteredPersonalStaticFields_;
+    std::vector<Registration> templateStaticFields_;
+    std::vector<MemberRegistrationError> unregisteredTemplateStaticFields_;
 };
 
 namespace Result
 {
-    extern vector<ProcessedEnum> enums_;
-    extern vector<ProcessedGlobalFunction> globalFunctions_;
-    extern vector<ProcessedGlobalVariable> globalVariables_;
-    extern vector<ProcessedClass> classes_;
+    extern std::vector<ProcessedEnum> enums_;
+    extern std::vector<ProcessedGlobalFunction> globalFunctions_;
+    extern std::vector<ProcessedGlobalVariable> globalVariables_;
+    extern std::vector<ProcessedClass> classes_;
 
     // Add header to lists if not added yet
-    void AddHeader(const string& headerFile);
+    void AddHeader(const std::string& headerFile);
 }
 
 } // namespace ASBindingGenerator

Source/Tools/BindingGenerator/ASUtils.cpp

@@ -29,6 +29,9 @@
 #include <cassert>
 #include <regex>
 
+using namespace std;
+using namespace pugi;
+
 namespace ASBindingGenerator
 {
 

Source/Tools/BindingGenerator/ASUtils.h

@@ -28,8 +28,6 @@
 #include <stdexcept>
 #include <string>
 
-using namespace std;
-
 namespace ASBindingGenerator
 {
 
@@ -43,14 +41,14 @@ enum class TypeUsage
 
 struct ConvertedVariable
 {
-    string asDeclaration_;
-    string cppDeclaration_;
-    string glue_;
+    std::string asDeclaration_;
+    std::string cppDeclaration_;
+    std::string glue_;
 
     bool NeedWrapper() const { return !glue_.empty(); }
 };
 
-string JoinASDeclarations(const vector<ConvertedVariable>& vars);
+std::string JoinASDeclarations(const std::vector<ConvertedVariable>& vars);
 
 enum class VariableUsage
 {
@@ -60,38 +58,38 @@ enum class VariableUsage
     Field,
 };
 
-ConvertedVariable CppVariableToAS(const TypeAnalyzer& type, VariableUsage usage, const string& name = "", const string& defaultValue = "");
+ConvertedVariable CppVariableToAS(const TypeAnalyzer& type, VariableUsage usage, const std::string& name = "", const std::string& defaultValue = "");
 
-string CppTypeToAS(const TypeAnalyzer& type, TypeUsage typeUsage);
+std::string CppTypeToAS(const TypeAnalyzer& type, TypeUsage typeUsage);
 
-shared_ptr<EnumAnalyzer> FindEnum(const string& name);
-string CppPrimitiveTypeToAS(const string& cppType);
-string CppValueToAS(const string& cppValue);
+std::shared_ptr<EnumAnalyzer> FindEnum(const std::string& name);
+std::string CppPrimitiveTypeToAS(const std::string& cppType);
+std::string CppValueToAS(const std::string& cppValue);
 
-class Exception : public runtime_error
+class Exception : public std::runtime_error
 {
     using runtime_error::runtime_error;
 };
 
-bool IsKnownCppType(const string& name);
+bool IsKnownCppType(const std::string& name);
 
-shared_ptr<ClassAnalyzer> FindClassByName(const string& name);
-shared_ptr<ClassAnalyzer> FindClassByID(const string& name);
+std::shared_ptr<ClassAnalyzer> FindClassByName(const std::string& name);
+std::shared_ptr<ClassAnalyzer> FindClassByID(const std::string& name);
 
-string GenerateWrapperName(const GlobalFunctionAnalyzer& functionAnalyzer);
-string GenerateWrapperName(const ClassStaticFunctionAnalyzer& functionAnalyzer);
-string GenerateWrapperName(const MethodAnalyzer& methodAnalyzer, bool templateVersion = false);
+std::string GenerateWrapperName(const GlobalFunctionAnalyzer& functionAnalyzer);
+std::string GenerateWrapperName(const ClassStaticFunctionAnalyzer& functionAnalyzer);
+std::string GenerateWrapperName(const MethodAnalyzer& methodAnalyzer, bool templateVersion = false);
 
-string GenerateWrapper(const GlobalFunctionAnalyzer& functionAnalyzer, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
-string GenerateWrapper(const ClassStaticFunctionAnalyzer& functionAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
-string GenerateWrapper(const MethodAnalyzer& methodAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
+std::string GenerateWrapper(const GlobalFunctionAnalyzer& functionAnalyzer, const std::vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
+std::string GenerateWrapper(const ClassStaticFunctionAnalyzer& functionAnalyzer, bool templateVersion, const std::vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
+std::string GenerateWrapper(const MethodAnalyzer& methodAnalyzer, bool templateVersion, const std::vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
 
-string GenerateConstructorWrapper(const MethodAnalyzer& methodAnalyzer, const vector<ConvertedVariable>& convertedParams);
-string GenerateFactoryWrapper(const MethodAnalyzer& methodAnalyzer, const vector<ConvertedVariable>& convertedParams);
+std::string GenerateConstructorWrapper(const MethodAnalyzer& methodAnalyzer, const std::vector<ConvertedVariable>& convertedParams);
+std::string GenerateFactoryWrapper(const MethodAnalyzer& methodAnalyzer, const std::vector<ConvertedVariable>& convertedParams);
 
 
-string Generate_asFUNCTIONPR(const GlobalFunctionAnalyzer& functionAnalyzer);
-string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer, bool templateVersion);
-string Generate_asMETHODPR(const MethodAnalyzer& methodAnalyzer, bool templateVersion);
+std::string Generate_asFUNCTIONPR(const GlobalFunctionAnalyzer& functionAnalyzer);
+std::string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer, bool templateVersion);
+std::string Generate_asMETHODPR(const MethodAnalyzer& methodAnalyzer, bool templateVersion);
 
 }

Source/Tools/BindingGenerator/Tuning.cpp

@@ -26,6 +26,8 @@
 #include "Tuning.h"
 #include "Utils.h"
 
+using namespace std;
+
 // Some parts of the engine are compiled only if there are defines
 string InsideDefine(const string& headerFile)
 {

Source/Tools/BindingGenerator/Tuning.h

@@ -24,7 +24,5 @@
 
 #include <string>
 
-using namespace std;
-
-string InsideDefine(const string& headerFile);
-bool IsIgnoredHeader(const string& headerFile);
+std::string InsideDefine(const std::string& headerFile);
+bool IsIgnoredHeader(const std::string& headerFile);

Source/Tools/BindingGenerator/Utils.cpp

@@ -25,6 +25,8 @@
 #include <cassert>
 #include <sstream>
 
+using namespace std;
+
 string Trim(const string& str)
 {
     size_t trimStart = 0;

Source/Tools/BindingGenerator/Utils.h

@@ -26,40 +26,38 @@
 #include <vector>
 #include <algorithm>
 
-using namespace std;
-
-#define CONTAINS(vec, val) (find(vec.begin(), vec.end(), val) != vec.end())
-
-string Trim(const string& str);
-bool StartsWith(const string& str, const string& value);
-bool EndsWith(const string& str, const string& value);
-string CutStart(const string& str, const string& value);
-string CutEnd(const string& str, const string& value);
-string GetFirstWord(const string& str);
-
-string ReplaceAll(const string& src, const string& from, const string& to);
-string RemoveAll(const string& src, const string& value);
-string ReplaceFirst(const string& src, const string& from, const string& to);
-string RemoveFirst(const string& src, const string& value);
-vector<string> Split(const string& str, char delim);
-vector<string> Split(const string& str, const string& delim);
-string Join(const vector<string>& values, const string& separator);
-
-bool Contains(const string& str, const string& substr);
-bool Contains(const string& str, char c);
+#define CONTAINS(vec, val) (std::find(vec.begin(), vec.end(), val) != vec.end())
+
+std::string Trim(const std::string& str);
+bool StartsWith(const std::string& str, const std::string& value);
+bool EndsWith(const std::string& str, const std::string& value);
+std::string CutStart(const std::string& str, const std::string& value);
+std::string CutEnd(const std::string& str, const std::string& value);
+std::string GetFirstWord(const std::string& str);
+
+std::string ReplaceAll(const std::string& src, const std::string& from, const std::string& to);
+std::string RemoveAll(const std::string& src, const std::string& value);
+std::string ReplaceFirst(const std::string& src, const std::string& from, const std::string& to);
+std::string RemoveFirst(const std::string& src, const std::string& value);
+std::vector<std::string> Split(const std::string& str, char delim);
+std::vector<std::string> Split(const std::string& str, const std::string& delim);
+std::string Join(const std::vector<std::string>& values, const std::string& separator);
+
+bool Contains(const std::string& str, const std::string& substr);
+bool Contains(const std::string& str, char c);
 
 // Return all after last found substring
-string CutToLast(const string& src, const string& value, bool inclusive);
+std::string CutToLast(const std::string& src, const std::string& value, bool inclusive);
 
 // Return all after last /
-string GetFileName(const string& path);
+std::string GetFileName(const std::string& path);
 
 // Return all before last /
-string WithoutFileName(const string& path);
+std::string WithoutFileName(const std::string& path);
 
 // First letter to lower case. Works only for ASCII
-string FirstCharToLower(const string& str);
+std::string FirstCharToLower(const std::string& str);
 
-string JoinNonEmpty(const vector<string>& strings, const string& separator);
+std::string JoinNonEmpty(const std::vector<std::string>& strings, const std::string& separator);
 
-string ToIdentifier(const string& str);
+std::string ToIdentifier(const std::string& str);

Source/Tools/BindingGenerator/XmlAnalyzer.cpp

@@ -27,6 +27,9 @@
 #include <cassert>
 #include <regex>
 
+using namespace std;
+using namespace pugi;
+
 extern string _sourceDir;
 
 string RemoveRefs(xml_node node)

Source/Tools/BindingGenerator/XmlAnalyzer.h

@@ -31,36 +31,33 @@
 #include "XmlSourceData.h"
 #include "Utils.h"
 
-using namespace pugi;
-using namespace std;
-
-using TemplateSpecialization = map<string, string>;
+using TemplateSpecialization = std::map<std::string, std::string>;
 
 // <type>...</type> | <defval>...</defval> | <para>...</para>
-string RemoveRefs(xml_node node);
+std::string RemoveRefs(pugi::xml_node node);
 
 // <type>...</type>
 class TypeAnalyzer
 {
 private:
-    string fullType_;
-    string name_;
+    std::string fullType_;
+    std::string name_;
     bool isConst_;
     bool isPointer_; // *
     bool isReference_; // &
     bool isRvalueReference_; // &&
     bool isDoublePointer_; // **
     bool isRefToPoiner_; // *&
-    string templateParams_;
+    std::string templateParams_;
 
 public:
-    TypeAnalyzer(xml_node type, const TemplateSpecialization& specialization = {});
+    TypeAnalyzer(pugi::xml_node type, const TemplateSpecialization& specialization = {});
 
     // Used for doxygen bug workaround https://github.com/doxygen/doxygen/issues/7732
-    TypeAnalyzer(const string& typeName);
+    TypeAnalyzer(const std::string& typeName);
 
-    string ToString() const { return fullType_; }
-    string GetName() const { return name_; }
+    std::string ToString() const { return fullType_; }
+    std::string GetName() const { return name_; }
     bool IsConst() const { return isConst_; }
     bool IsPointer() const { return isPointer_; }
     bool IsReference() const { return isReference_; }
@@ -68,8 +65,8 @@ public:
     bool IsDoublePointer() const { return isDoublePointer_; }
     bool IsRefToPointer() const { return isRefToPoiner_; }
     bool IsTemplate() const { return templateParams_.length() > 0; }
-    string GetTemplateParams() { return templateParams_; }
-    string GetNameWithTemplateParams() const { return IsTemplate() ? name_ + "<" + templateParams_ + ">" : name_; }
+    std::string GetTemplateParams() { return templateParams_; }
+    std::string GetNameWithTemplateParams() const { return IsTemplate() ? name_ + "<" + templateParams_ + ">" : name_; }
 };
 
 // <memberdef kind="function">
@@ -77,15 +74,15 @@ public:
 class ParamAnalyzer
 {
 private:
-    xml_node node_;
+    pugi::xml_node node_;
     TemplateSpecialization specialization_; 
 
 public:
-    ParamAnalyzer(xml_node param, const TemplateSpecialization& specialization = {});
+    ParamAnalyzer(pugi::xml_node param, const TemplateSpecialization& specialization = {});
 
-    xml_node GetNode() const { return node_; }
+    pugi::xml_node GetNode() const { return node_; }
 
-    string ToString() const;
+    std::string ToString() const;
 
     // <param>
     //     <type>....</type>
@@ -93,146 +90,146 @@ public:
 
     // <param>
     //     <declname>....</declname>
-    string GetDeclname() const;
+    std::string GetDeclname() const;
 
     // <param>
     //     <defval>....</defval>
-    string GetDefval() const; // Default value
+    std::string GetDefval() const; // Default value
 };
 
 // <memberdef>
-inline bool IsMemberdef(xml_node node) { return node.name() == string("memberdef"); }
+inline bool IsMemberdef(pugi::xml_node node) { return node.name() == std::string("memberdef"); }
 
 // <compounddef>
-inline bool IsCompounddef(xml_node node) { return node.name() == string("compounddef"); }
+inline bool IsCompounddef(pugi::xml_node node) { return node.name() == std::string("compounddef"); }
 
 // <member>
-inline bool IsMember(xml_node node) { return node.name() == string("member"); }
+inline bool IsMember(pugi::xml_node node) { return node.name() == std::string("member"); }
 
 // <sectiondef>
-inline bool IsSectiondef(xml_node node) { return node.name() == string("sectiondef"); }
+inline bool IsSectiondef(pugi::xml_node node) { return node.name() == std::string("sectiondef"); }
 
 // <enumvalue>
-inline bool IsEnumvalue(xml_node node) { return node.name() == string("enumvalue"); }
+inline bool IsEnumvalue(pugi::xml_node node) { return node.name() == std::string("enumvalue"); }
 
 // <compounddef>
 //     <compoundname>...</compoundname>
-string ExtractCompoundname(xml_node compounddef);
+std::string ExtractCompoundname(pugi::xml_node compounddef);
 
 // <compounddef>
 //     <sectiondef kind="xxx">...</sectiondef>
-xml_node FindSectiondef(xml_node compounddef, const string& kind);
+pugi::xml_node FindSectiondef(pugi::xml_node compounddef, const std::string& kind);
 
 // <memberdef static="yes">
-bool IsStatic(xml_node memberdef);
+bool IsStatic(pugi::xml_node memberdef);
 
 // <memberdef kind="function" explicit="yes">
-bool IsExplicit(xml_node memberdef);
+bool IsExplicit(pugi::xml_node memberdef);
 
 // <memberdef>
 //     <definition>...</definition>
-string ExtractDefinition(xml_node memberdef);
+std::string ExtractDefinition(pugi::xml_node memberdef);
 
 // <memberdef>
 //     <argsstring>...</argsstring>
-string ExtractArgsstring(xml_node memberdef);
+std::string ExtractArgsstring(pugi::xml_node memberdef);
 
 // <memberdef kind="function">
 //     <argsstring>(...)</argsstring>
 //     <argsstring>(...) xxx</argsstring>
 //         where xxx can be of const, override, =default, =delete, =0 or their combination
-string ExtractCleanedFunctionArgsstring(xml_node memberdef);
+std::string ExtractCleanedFunctionArgsstring(pugi::xml_node memberdef);
 
 // <memberdef prot="...">
-string ExtractProt(xml_node memberdef);
+std::string ExtractProt(pugi::xml_node memberdef);
 
 // <memberdef>
 //     <type>...</type>
-TypeAnalyzer ExtractType(xml_node memberdef, const TemplateSpecialization& specialization = {});
+TypeAnalyzer ExtractType(pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
 
 // <memberdef kind="function">
 //     <param>...</param>
 //     <param>...</param>
-vector<ParamAnalyzer> ExtractParams(xml_node memberdef, const TemplateSpecialization& specialization = {});
+std::vector<ParamAnalyzer> ExtractParams(pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
 
 // <memberdef kind="function">
 //     <param>...</param>
 //     <param>...</param>
-string JoinParamsTypes(xml_node memberdef, const TemplateSpecialization& specialization = {});
-string JoinParamsNames(xml_node memberdef, bool skipContext = false);
+std::string JoinParamsTypes(pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
+std::string JoinParamsNames(pugi::xml_node memberdef, bool skipContext = false);
 
 // <memberdef kind="function">
 //     ...
-string GetFunctionDeclaration(xml_node memberdef);
+std::string GetFunctionDeclaration(pugi::xml_node memberdef);
 
 // <memberdef kind="variable">
 //     ...
-string GetVariableDeclaration(xml_node memberdef);
+std::string GetVariableDeclaration(pugi::xml_node memberdef);
 
 // <memberdef kind="function">
 //     ...
-string GetFunctionLocation(xml_node memberdef);
+std::string GetFunctionLocation(pugi::xml_node memberdef);
 
 // <compounddef|memberdef id="...">
-string ExtractID(xml_node node);
+std::string ExtractID(pugi::xml_node node);
 
 // <compounddef|memberdef|member|sectiondef kind="...">
-string ExtractKind(xml_node node);
+std::string ExtractKind(pugi::xml_node node);
 
 // <memberdef|enumvalue>
 //     <name>...</name>
-string ExtractName(xml_node node);
+std::string ExtractName(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <location line="...">
-string ExtractLine(xml_node node);
+std::string ExtractLine(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <location column="...">
-string ExtractColumn(xml_node node);
+std::string ExtractColumn(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <briefdescription>...</briefdescription>
 //     <detaileddescription>...</detaileddescription>
-string ExtractComment(xml_node node);
+std::string ExtractComment(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <location ...>
 // Extract header file path and convert to relative.
-// Return empty string when declared in *.cpp
-string ExtractHeaderFile(xml_node node);
+// Return empty std::string when declared in *.cpp
+std::string ExtractHeaderFile(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <templateparamlist>
-bool IsTemplate(xml_node node);
+bool IsTemplate(pugi::xml_node node);
 
 // <compounddef|memberdef>
 //     <templateparamlist>
 //         <param>...</param>
 //         <param>...</param>
-vector<string> ExtractTemplateParams(xml_node node);
+std::vector<std::string> ExtractTemplateParams(pugi::xml_node node);
 
 // <compounddef kind="namespace">
 //     <sectiondef kind="enum">
 //         <memberdef kind="enum">...</memberdef>
 class EnumAnalyzer
 {
-    xml_node memberdef_;
+    pugi::xml_node memberdef_;
 
 public:
-    EnumAnalyzer(xml_node memberdef);
+    EnumAnalyzer(pugi::xml_node memberdef);
 
-    string GetTypeName() const { return ExtractName(memberdef_); }
-    string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
-    string GetComment() const { return ExtractComment(memberdef_); }
+    std::string GetTypeName() const { return ExtractName(memberdef_); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
+    std::string GetComment() const { return ExtractComment(memberdef_); }
     bool IsInternal() const { return GetHeaderFile().empty(); } // true if declared in .cpp file
-    string GetBaseType() const;
-    string GetLocation() const;
+    std::string GetBaseType() const;
+    std::string GetLocation() const;
 
     // <memberdef kind="enum">
     //     <enumvalue><name>...</name></enumvalue>
     //     <enumvalue><name>...</name></enumvalue>
-    vector<string> GetEnumerators() const;
+    std::vector<std::string> GetEnumerators() const;
 
 };
 
@@ -241,17 +238,17 @@ public:
 //         <memberdef kind="variable">...</memberdef>
 class GlobalVariableAnalyzer
 {
-    xml_node memberdef_;
+    pugi::xml_node memberdef_;
 
 public:
-    GlobalVariableAnalyzer(xml_node memberdef);
+    GlobalVariableAnalyzer(pugi::xml_node memberdef);
 
-    string GetName() const { return ExtractName(memberdef_); }
-    string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
+    std::string GetName() const { return ExtractName(memberdef_); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
     bool IsStatic() const { return ::IsStatic(memberdef_); }
     TypeAnalyzer GetType() const { return ExtractType(memberdef_); }
     bool IsArray() const { return StartsWith(ExtractArgsstring(memberdef_), "["); }
-    string GetLocation() const { return GetVariableDeclaration(memberdef_) + " | File: " + GetHeaderFile(); }
+    std::string GetLocation() const { return GetVariableDeclaration(memberdef_) + " | File: " + GetHeaderFile(); }
 };
 
 class MethodAnalyzer;
@@ -261,99 +258,99 @@ class FieldAnalyzer;
 class ClassAnalyzer
 {
 private:
-    xml_node compounddef_;
+    pugi::xml_node compounddef_;
     TemplateSpecialization specialization_;
     
-    vector<xml_node> GetMemberdefs() const;
+    std::vector<pugi::xml_node> GetMemberdefs() const;
 
 public:
-    string usingLocation_;
+    std::string usingLocation_;
 
-    xml_node GetCompounddef() const { return compounddef_; }
+    pugi::xml_node GetCompounddef() const { return compounddef_; }
 
-    ClassAnalyzer(xml_node compounddef, const TemplateSpecialization& specialization = {});
+    ClassAnalyzer(pugi::xml_node compounddef, const TemplateSpecialization& specialization = {});
 
     const TemplateSpecialization& GetSpecialization() const { return specialization_; }
 
-    string GetClassName() const;
-    string GetComment() const { return ExtractComment(compounddef_); }
-    string GetHeaderFile() const { return ExtractHeaderFile(compounddef_); }
-    string GetDirName() const;
-    string GetKind() const { return ExtractKind(compounddef_); }
+    std::string GetClassName() const;
+    std::string GetComment() const { return ExtractComment(compounddef_); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(compounddef_); }
+    std::string GetDirName() const;
+    std::string GetKind() const { return ExtractKind(compounddef_); }
     bool IsInternal() const;
     bool IsTemplate() const { return ::IsTemplate(compounddef_); }
-    vector<MethodAnalyzer> GetAllMethods() const;
-    vector<MethodAnalyzer> GetAllPublicMethods() const;
-    vector<MethodAnalyzer> GetThisPublicMethods() const;
-    vector<MethodAnalyzer> GetThisPublicStaticMethods() const;
-    vector<FieldAnalyzer> GetAllFields() const;
-    vector<FieldAnalyzer> GetThisPublicFields() const;
-    vector<FieldAnalyzer> GetThisPublicStaticFields() const;
-    bool ContainsMethod(const string& name) const;
-    shared_ptr<MethodAnalyzer> GetMethod(const string& name) const;
-    int NumMethods(const string& name) const;
+    std::vector<MethodAnalyzer> GetAllMethods() const;
+    std::vector<MethodAnalyzer> GetAllPublicMethods() const;
+    std::vector<MethodAnalyzer> GetThisPublicMethods() const;
+    std::vector<MethodAnalyzer> GetThisPublicStaticMethods() const;
+    std::vector<FieldAnalyzer> GetAllFields() const;
+    std::vector<FieldAnalyzer> GetThisPublicFields() const;
+    std::vector<FieldAnalyzer> GetThisPublicStaticFields() const;
+    bool ContainsMethod(const std::string& name) const;
+    std::shared_ptr<MethodAnalyzer> GetMethod(const std::string& name) const;
+    int NumMethods(const std::string& name) const;
     bool IsRefCounted() const;
     bool HasThisDestructor() const { return ContainsMethod("~" + GetClassName()); }
     bool HasThisConstructor() const;
     bool IsAbstract() const;
-    string GetLocation() const { return GetKind() + " " + GetClassName() + " | File: " + GetHeaderFile(); }
+    std::string GetLocation() const { return GetKind() + " " + GetClassName() + " | File: " + GetHeaderFile(); }
     bool AllFloats() const;
     bool AllInts() const;
     bool IsPod() const;
     bool IsNoCount() const { return Contains(GetComment(), "NO_COUNT"); } // Have @nocount in comment -> asOBJ_NOCOUNT
-    shared_ptr<ClassAnalyzer> GetBaseClass() const;
-    vector<ClassAnalyzer> GetBaseClasses() const;
-    vector<ClassAnalyzer> GetAllBaseClasses() const;
+    std::shared_ptr<ClassAnalyzer> GetBaseClass() const;
+    std::vector<ClassAnalyzer> GetBaseClasses() const;
+    std::vector<ClassAnalyzer> GetAllBaseClasses() const;
 
-    vector<ClassAnalyzer> GetDerivedClasses() const;
-    vector<ClassAnalyzer> GetAllDerivedClasses() const;
+    std::vector<ClassAnalyzer> GetDerivedClasses() const;
+    std::vector<ClassAnalyzer> GetAllDerivedClasses() const;
     
     // Return null if default constructor is implicitly-declared.
     // Return pointer if default constructor is deleted
-    shared_ptr<MethodAnalyzer> GetDefinedThisDefaultConstructor() const;
+    std::shared_ptr<MethodAnalyzer> GetDefinedThisDefaultConstructor() const;
 
-    vector<MethodAnalyzer> GetThisNonDefaultConstructors() const;
+    std::vector<MethodAnalyzer> GetThisNonDefaultConstructors() const;
 
     // Return null if destructor is implicitly-declared.
     // Return pointer if destructor is deleted
-    shared_ptr<MethodAnalyzer> GetDefinedThisDestructor() const { return GetMethod("~" + GetClassName()); }
+    std::shared_ptr<MethodAnalyzer> GetDefinedThisDestructor() const { return GetMethod("~" + GetClassName()); }
 
     int GetInherianceDeep(int counter = 0) const;
     
-    vector<string> GetAllPublicMembersRefids() const;
+    std::vector<std::string> GetAllPublicMembersRefids() const;
 
     // Base class members that were hidden in this class (c++ declarations)
-    vector<string> GetHiddenMethods() const;
-    vector<string> GetHiddenStaticMethods() const;
-    vector<string> GetHiddenFields() const;
-    vector<string> GetHiddenStaticFields() const;
+    std::vector<std::string> GetHiddenMethods() const;
+    std::vector<std::string> GetHiddenStaticMethods() const;
+    std::vector<std::string> GetHiddenFields() const;
+    std::vector<std::string> GetHiddenStaticFields() const;
 };
 
 // <memberdef kind="function">...</memberdef>
 class FunctionAnalyzer
 {
 protected:
-    xml_node memberdef_;
+    pugi::xml_node memberdef_;
     TemplateSpecialization specialization_;
 
 public:
-    FunctionAnalyzer(xml_node memberdef, const TemplateSpecialization& specialization = {});
+    FunctionAnalyzer(pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
     
-    xml_node GetMemberdef() const { return memberdef_; }
+    pugi::xml_node GetMemberdef() const { return memberdef_; }
     const TemplateSpecialization& GetSpecialization() const { return specialization_; }
 
-    string GetComment() const { return ExtractComment(memberdef_); }
-    string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
-    string GetName() const { return ExtractName(memberdef_); }
-    vector<ParamAnalyzer> GetParams() const { return ExtractParams(memberdef_, specialization_); }
+    std::string GetComment() const { return ExtractComment(memberdef_); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
+    std::string GetName() const { return ExtractName(memberdef_); }
+    std::vector<ParamAnalyzer> GetParams() const { return ExtractParams(memberdef_, specialization_); }
     TypeAnalyzer GetReturnType() const { return ExtractType(memberdef_, specialization_); }
-    vector<string> GetTemplateParams() const { return ExtractTemplateParams(memberdef_); }
+    std::vector<std::string> GetTemplateParams() const { return ExtractTemplateParams(memberdef_); }
     bool IsDefine() const { return CONTAINS(SourceData::defines_, GetName()); }
     bool IsTemplate() const { return ::IsTemplate(memberdef_); }
-    string JoinParamsNames(bool skipContext = false) const { return ::JoinParamsNames(memberdef_, skipContext); } // TODO убрать skipContext, он больше не нужен
-    string JoinParamsTypes() const { return ::JoinParamsTypes(memberdef_, specialization_); }
+    std::string JoinParamsNames(bool skipContext = false) const { return ::JoinParamsNames(memberdef_, skipContext); } // TODO убрать skipContext, он больше не нужен
+    std::string JoinParamsTypes() const { return ::JoinParamsTypes(memberdef_, specialization_); }
 
-    virtual string GetLocation() const { return GetFunctionLocation(memberdef_); }
+    virtual std::string GetLocation() const { return GetFunctionLocation(memberdef_); }
 };
 
 // <compounddef kind="class|struct">
@@ -364,12 +361,12 @@ class MethodAnalyzer : public FunctionAnalyzer
     ClassAnalyzer classAnalyzer_;
 
 public:
-    MethodAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization = {});
+    MethodAnalyzer(const ClassAnalyzer& classAnalyzer, pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
 
     ClassAnalyzer GetClass() const { return classAnalyzer_; }
 
     // <memberdef kind="function" virt="...">
-    string GetVirt() const;
+    std::string GetVirt() const;
     bool IsPureVirtual() const { return GetVirt() == "pure-virtual"; }
 
     // <memberdef kind="function" const="yes">
@@ -377,10 +374,10 @@ public:
 
     // <memberdef>
     // <reimplements refid="..."></reimplements>
-    shared_ptr<MethodAnalyzer> Reimplements() const;
+    std::shared_ptr<MethodAnalyzer> Reimplements() const;
 
-    string GetClassName() const { return classAnalyzer_.GetClassName(); }
-    string GetContainsClassName() const; // May this function defined in parent class, so return name oа class, real define this function
+    std::string GetClassName() const { return classAnalyzer_.GetClassName(); }
+    std::string GetContainsClassName() const; // May this function defined in parent class, so return name oа class, real define this function
     bool IsStatic() const { return ::IsStatic(memberdef_); }
     bool IsPublic() const { return ExtractProt(memberdef_) == "public"; }
 
@@ -402,8 +399,8 @@ public:
 
     bool IsThisMethod() const { return GetContainsClassName() == GetClassName(); } // Defined in this class
 
-    string GetDeclaration() const { return JoinNonEmpty({ classAnalyzer_.usingLocation_, GetFunctionDeclaration(memberdef_) }, " | "); }
-    string GetLocation() const override { return JoinNonEmpty({ classAnalyzer_.usingLocation_, GetFunctionLocation(memberdef_) }, " | "); }
+    std::string GetDeclaration() const { return JoinNonEmpty({ classAnalyzer_.usingLocation_, GetFunctionDeclaration(memberdef_) }, " | "); }
+    std::string GetLocation() const override { return JoinNonEmpty({ classAnalyzer_.usingLocation_, GetFunctionLocation(memberdef_) }, " | "); }
 };
 
 // <compounddef kind="class|struct">
@@ -412,20 +409,20 @@ public:
 class FieldAnalyzer
 {
     ClassAnalyzer classAnalyzer_;
-    xml_node memberdef_;
+    pugi::xml_node memberdef_;
 
 public:
-    FieldAnalyzer(ClassAnalyzer classAnalyzer, xml_node memberdef);
+    FieldAnalyzer(ClassAnalyzer classAnalyzer, pugi::xml_node memberdef);
 
     bool IsStatic() const { return ::IsStatic(memberdef_); }
     TypeAnalyzer GetType() const { return ExtractType(memberdef_); }
-    string GetName() const { return ExtractName(memberdef_); }
-    string GetComment() const { return ExtractComment(memberdef_); }
+    std::string GetName() const { return ExtractName(memberdef_); }
+    std::string GetComment() const { return ExtractComment(memberdef_); }
     bool IsPublic() const { return ExtractProt(memberdef_) == "public"; }
-    string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
-    string GetDeclaration() const { return GetVariableDeclaration(memberdef_); }
-    string GetLocation() const;
-    string GetClassName() const { return classAnalyzer_.GetClassName(); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
+    std::string GetDeclaration() const { return GetVariableDeclaration(memberdef_); }
+    std::string GetLocation() const;
+    std::string GetClassName() const { return classAnalyzer_.GetClassName(); }
     bool IsArray() const { return StartsWith(ExtractArgsstring(memberdef_), "["); };
 };
 
@@ -435,7 +432,7 @@ public:
 class GlobalFunctionAnalyzer : public FunctionAnalyzer
 {
 public:
-    GlobalFunctionAnalyzer(xml_node memberdef, const TemplateSpecialization& specialization = {});
+    GlobalFunctionAnalyzer(pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
 };
 
 // <compounddef kind="class|struct">
@@ -446,9 +443,9 @@ class ClassStaticFunctionAnalyzer : public FunctionAnalyzer
     ClassAnalyzer classAnalyzer_;
 
 public:
-    ClassStaticFunctionAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization = {});
+    ClassStaticFunctionAnalyzer(const ClassAnalyzer& classAnalyzer, pugi::xml_node memberdef, const TemplateSpecialization& specialization = {});
 
-    string GetClassName() const { return classAnalyzer_.GetClassName(); }
+    std::string GetClassName() const { return classAnalyzer_.GetClassName(); }
 };
 
 // <memberdef kind="typedef">
@@ -456,15 +453,15 @@ public:
 class UsingAnalyzer
 {
 private:
-    xml_node memberdef_;
+    pugi::xml_node memberdef_;
 
 public:
-    UsingAnalyzer(xml_node memberdef);
+    UsingAnalyzer(pugi::xml_node memberdef);
 
-    string GetComment() const { return ExtractComment(memberdef_); }
-    string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
-    string GetLocation() const { return "using " + GetName() + " = " + GetType().ToString() + " | File: " + GetHeaderFile(); }
-    string GetName() const { return ExtractName(memberdef_); }
+    std::string GetComment() const { return ExtractComment(memberdef_); }
+    std::string GetHeaderFile() const { return ExtractHeaderFile(memberdef_); }
+    std::string GetLocation() const { return "using " + GetName() + " = " + GetType().ToString() + " | File: " + GetHeaderFile(); }
+    std::string GetName() const { return ExtractName(memberdef_); }
     TypeAnalyzer GetType() const { return ExtractType(memberdef_); }
 };
 
@@ -472,27 +469,27 @@ public:
 class NamespaceAnalyzer
 {
 private:
-    xml_node compounddef_;
+    pugi::xml_node compounddef_;
 
 public:
-    NamespaceAnalyzer(xml_node compounddef);
+    NamespaceAnalyzer(pugi::xml_node compounddef);
 
     // <compounddef kind="namespace">
     //     <sectiondef kind="enum">
     //         <memberdef kind="enum">...</memberdef>
     //         <memberdef kind="enum">...</memberdef>
-    vector<EnumAnalyzer> GetEnums();
+    std::vector<EnumAnalyzer> GetEnums();
 
     // <compounddef kind="namespace">
     //     <sectiondef kind="var">
     //         <memberdef kind="variable">...</memberdef>
     //         <memberdef kind="variable">...</memberdef>
-    vector<GlobalVariableAnalyzer> GetVariables();
+    std::vector<GlobalVariableAnalyzer> GetVariables();
 
     // <compounddef kind="namespace">
     //     <sectiondef kind="func">
     //         <memberdef kind="function">...</memberdef>
     //         <memberdef kind="function">...</memberdef>
-    vector<GlobalFunctionAnalyzer> GetFunctions();
+    std::vector<GlobalFunctionAnalyzer> GetFunctions();
 };
 

Source/Tools/BindingGenerator/XmlSourceData.cpp

@@ -37,6 +37,9 @@
 #include <sys/stat.h>
 #endif
 
+using namespace std;
+using namespace pugi;
+
 static void LoadXml(const string& fullPath)
 {
     // All loaded XMLs. Not used directly, just prevents destruction

Source/Tools/BindingGenerator/XmlSourceData.h

@@ -27,35 +27,32 @@
 #include <unordered_map>
 #include <vector>
 
-using namespace std;
-using namespace pugi;
-
 namespace SourceData
 {
     // All classes and structs
-    extern unordered_map<string, xml_node> classesByID_; // id -> compounddef
+    extern std::unordered_map<std::string, pugi::xml_node> classesByID_; // id -> compounddef
 
     // All classes and structs from Urho3D namepace
-    extern unordered_map<string, xml_node> classesByName_; // name -> compounddef
+    extern std::unordered_map<std::string, pugi::xml_node> classesByName_; // name -> compounddef
 
     // Huge table with all members of all classes and structs
-    extern unordered_map<string, xml_node> members_; // id -> memberdef
+    extern std::unordered_map<std::string, pugi::xml_node> members_; // id -> memberdef
 
     // All enums from Urho3D namepace
-    extern unordered_map<string, xml_node> enums_; // name -> memberdef
+    extern std::unordered_map<std::string, pugi::xml_node> enums_; // name -> memberdef
 
     // List of all defines. Used to detect that some function is a define actually
-    extern vector<string> defines_;
+    extern std::vector<std::string> defines_;
 
     // Namespace Urho3D contains enums, global functions and global variables
-    extern xml_node namespaceUrho3D_; // compounddef from file namespace_urho3_d.xml
+    extern pugi::xml_node namespaceUrho3D_; // compounddef from file namespace_urho3_d.xml
 
     // All usings from namespace Urho3D
-    extern vector<xml_node> usings_; // memberdefs
+    extern std::vector<pugi::xml_node> usings_; // memberdefs
 
     // Header files with @nobindfile mark at the beginning
-    extern vector<string> ignoredHeaders_;
+    extern std::vector<std::string> ignoredHeaders_;
 
     // Init all variables above
-    void LoadAllXmls(const string& dir);
+    void LoadAllXmls(const std::string& dir);
 }