Compile opencv_test_core with cv::String instead of std::string

All tests passed!

cmake/OpenCVModule.cmake

@@ -471,6 +471,9 @@ endmacro()
 #   ocv_create_module(SKIP_LINK)
 macro(ocv_create_module)
   add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES})
+  if(NOT the_module STREQUAL opencv_ts)
+    set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL)
+  endif()
 
   if(NOT "${ARGN}" STREQUAL "SKIP_LINK")
     target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
@@ -507,8 +510,6 @@ macro(ocv_create_module)
     )
   endif()
 
-  set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL)
-
   if(BUILD_SHARED_LIBS)
     if(MSVC)
       set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)

cmake/OpenCVPCHSupport.cmake

@@ -46,6 +46,13 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
             LIST(APPEND ${_out_compile_flags} "-fPIC")
         ENDIF()
 
+        GET_TARGET_PROPERTY(_target_definitions ${_PCH_current_target} COMPILE_DEFINITIONS)
+        if(_target_definitions)
+          foreach(_def ${_target_definitions})
+            LIST(APPEND ${_out_compile_flags} "-D${_def}")
+          endforeach()
+        endif()
+
     ELSE()
         ## TODO ... ? or does it work out of the box
     ENDIF()

modules/core/doc/command_line_parser.rst

@@ -16,7 +16,7 @@ The CommandLineParser class is designed for command line arguments parsing
         :param argv:
         :param keys:
 
-    .. ocv:function:: template<typename T> T CommandLineParser::get<T>(const std::string& name, bool space_delete = true)
+    .. ocv:function:: template<typename T> T CommandLineParser::get<T>(const cv::String& name, bool space_delete = true)
 
         :param name:
         :param space_delete:
@@ -26,7 +26,7 @@ The CommandLineParser class is designed for command line arguments parsing
         :param index:
         :param space_delete:
 
-    .. ocv:function:: bool CommandLineParser::has(const std::string& name)
+    .. ocv:function:: bool CommandLineParser::has(const cv::String& name)
 
         :param name:
 
@@ -41,7 +41,7 @@ The CommandLineParser class is designed for command line arguments parsing
 
     .. ocv:function:: void CommandLineParser::printErrors()
 
-    .. ocv:function:: std::string CommandLineParser::getPathToApplication()
+    .. ocv:function:: cv::String CommandLineParser::getPathToApplication()
 
 
 The sample below demonstrates how to use CommandLineParser:
@@ -59,12 +59,12 @@ The sample below demonstrates how to use CommandLineParser:
 
     int N = parser.get<int>("N");
     double fps = parser.get<double>("fps");
-    std::string path = parser.get<std::string>("path");
+    cv::String path = parser.get<cv::String>("path");
 
     use_time_stamp = parser.has("timestamp");
 
-    std::string img1 = parser.get<string>(0);
+    cv::String img1 = parser.get<string>(0);
-    std::string img2 = parser.get<string>(1);
+    cv::String img2 = parser.get<string>(1);
 
     int repeat = parser.get<int>(2);
 
@@ -78,7 +78,7 @@ Syntax:
 
 ::
 
-    const std::string keys =
+    const cv::String keys =
         "{help h usage ? |      | print this message   }"
         "{@image1        |      | image1 for compare   }"
         "{@image2        |      | image2 for compare   }"

modules/core/doc/utility_and_system_functions_and_macros.rst

@@ -284,7 +284,7 @@ getBuildInformation
 -------------------
 Returns full configuration time cmake output.
 
-.. ocv:function:: const std::string& getBuildInformation()
+.. ocv:function:: const cv::String& getBuildInformation()
 
 Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc. Output format depends on target architecture.
 

modules/core/doc/xml_yaml_persistence.rst

@@ -113,7 +113,7 @@ Here is how to read the file created by the code sample above: ::
     // first method: use (type) operator on FileNode.
     int frameCount = (int)fs2["frameCount"];
 
-    std::string date;
+    cv::String date;
     // second method: use FileNode::operator >>
     fs2["calibrationDate"] >> date;
 
@@ -548,11 +548,11 @@ Returns the node content as double.
     :returns: The node content as double.
 
 
-FileNode::operator std::string
+FileNode::operator cv::String
 ------------------------------
 Returns the node content as text string.
 
-.. ocv:function:: FileNode::operator std::string() const
+.. ocv:function:: FileNode::operator cv::String() const
 
     :returns: The node content as a text string.
 

modules/core/include/opencv2/core.hpp

@@ -126,7 +126,7 @@ public:
      Full constructor. Normally the constuctor is not called explicitly.
      Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used.
     */
-    Exception(int _code, const std::string& _err, const std::string& _func, const std::string& _file, int _line);
+    Exception(int _code, const cv::String& _err, const cv::String& _func, const cv::String& _file, int _line);
     virtual ~Exception() throw();
 
     /*!
@@ -135,12 +135,12 @@ public:
     virtual const char *what() const throw();
     void formatMessage();
 
-    std::string msg; ///< the formatted error message
+    cv::String msg; ///< the formatted error message
 
     int code; ///< error code @see CVStatus
-    std::string err; ///< error description
+    cv::String err; ///< error description
-    std::string func; ///< function name. Available only when the compiler supports __func__ macro
+    cv::String func; ///< function name. Available only when the compiler supports __func__ macro
-    std::string file; ///< source file name where the error has occured
+    cv::String file; ///< source file name where the error has occured
     int line; ///< line number in the source file where the error has occured
 };
 
@@ -2515,13 +2515,13 @@ enum
 };
 
 //! renders text string in the image
-CV_EXPORTS_W void putText( Mat& img, const std::string& text, Point org,
+CV_EXPORTS_W void putText( Mat& img, const cv::String& text, Point org,
                          int fontFace, double fontScale, Scalar color,
                          int thickness=1, int lineType=8,
                          bool bottomLeftOrigin=false );
 
 //! returns bounding box of the text string
-CV_EXPORTS_W Size getTextSize(const std::string& text, int fontFace,
+CV_EXPORTS_W Size getTextSize(const cv::String& text, int fontFace,
                             double fontScale, int thickness,
                             CV_OUT int* baseLine);
 
@@ -3766,7 +3766,7 @@ class CV_EXPORTS FileNode;
  FileStorage fs("test.yml", FileStorage::READ);
  int test_int = (int)fs["test_int"];
  double test_real = (double)fs["test_real"];
- std::string test_string = (std::string)fs["test_string"];
+ cv::String test_string = (cv::String)fs["test_string"];
 
  Mat M;
  fs["test_mat"] >> M;
@@ -3777,7 +3777,7 @@ class CV_EXPORTS FileNode;
  int tl1 = (int)tl[1];
  double tl2 = (double)tl[2];
  int tl3 = (int)tl[3];
- std::string tl4 = (std::string)tl[4];
+ cv::String tl4 = (cv::String)tl[4];
  CV_Assert(tl[5].type() == FileNode::MAP && tl[5].size() == 3);
 
  int month = (int)tl[5]["month"];
@@ -3823,27 +3823,27 @@ public:
     //! the default constructor
     CV_WRAP FileStorage();
     //! the full constructor that opens file storage for reading or writing
-    CV_WRAP FileStorage(const std::string& source, int flags, const std::string& encoding=std::string());
+    CV_WRAP FileStorage(const cv::String& source, int flags, const cv::String& encoding=cv::String());
     //! the constructor that takes pointer to the C FileStorage structure
     FileStorage(CvFileStorage* fs);
     //! the destructor. calls release()
     virtual ~FileStorage();
 
     //! opens file storage for reading or writing. The previous storage is closed with release()
-    CV_WRAP virtual bool open(const std::string& filename, int flags, const std::string& encoding=std::string());
+    CV_WRAP virtual bool open(const cv::String& filename, int flags, const cv::String& encoding=cv::String());
     //! returns true if the object is associated with currently opened file.
     CV_WRAP virtual bool isOpened() const;
     //! closes the file and releases all the memory buffers
     CV_WRAP virtual void release();
     //! closes the file, releases all the memory buffers and returns the text string
-    CV_WRAP virtual std::string releaseAndGetString();
+    CV_WRAP virtual cv::String releaseAndGetString();
 
     //! returns the first element of the top-level mapping
     CV_WRAP FileNode getFirstTopLevelNode() const;
     //! returns the top-level mapping. YAML supports multiple streams
     CV_WRAP FileNode root(int streamidx=0) const;
     //! returns the specified element of the top-level mapping
-    FileNode operator[](const std::string& nodename) const;
+    FileNode operator[](const cv::String& nodename) const;
     //! returns the specified element of the top-level mapping
     CV_WRAP FileNode operator[](const char* nodename) const;
 
@@ -3852,15 +3852,15 @@ public:
     //! returns pointer to the underlying C FileStorage structure
     const CvFileStorage* operator *() const { return fs; }
     //! writes one or more numbers of the specified format to the currently written structure
-    void writeRaw( const std::string& fmt, const uchar* vec, size_t len );
+    void writeRaw( const cv::String& fmt, const uchar* vec, size_t len );
     //! writes the registered C structure (CvMat, CvMatND, CvSeq). See cvWrite()
-    void writeObj( const std::string& name, const void* obj );
+    void writeObj( const cv::String& name, const void* obj );
 
     //! returns the normalized object name for the specified file name
-    static std::string getDefaultObjectName(const std::string& filename);
+    static cv::String getDefaultObjectName(const cv::String& filename);
 
     Ptr<CvFileStorage> fs; //!< the underlying C FileStorage structure
-    std::string elname; //!< the currently written element
+    cv::String elname; //!< the currently written element
     std::vector<char> structs; //!< the stack of written structures
     int state; //!< the writer state
 };
@@ -3905,7 +3905,7 @@ public:
     //! the copy constructor
     FileNode(const FileNode& node);
     //! returns element of a mapping node
-    FileNode operator[](const std::string& nodename) const;
+    FileNode operator[](const cv::String& nodename) const;
     //! returns element of a mapping node
     CV_WRAP FileNode operator[](const char* nodename) const;
     //! returns element of a sequence node
@@ -3930,7 +3930,7 @@ public:
     //! returns true if the node has a name
     CV_WRAP bool isNamed() const;
     //! returns the node name or an empty string if the node is nameless
-    CV_WRAP std::string name() const;
+    CV_WRAP cv::String name() const;
     //! returns the number of elements in the node, if it is a sequence or mapping, or 1 otherwise.
     CV_WRAP size_t size() const;
     //! returns the node content as an integer. If the node stores floating-point number, it is rounded.
@@ -3956,7 +3956,7 @@ public:
     FileNodeIterator end() const;
 
     //! reads node elements to the buffer with the specified format
-    void readRaw( const std::string& fmt, uchar* vec, size_t len ) const;
+    void readRaw( const cv::String& fmt, uchar* vec, size_t len ) const;
     //! reads the registered object and returns pointer to it
     void* readObj() const;
 
@@ -3999,7 +3999,7 @@ public:
     FileNodeIterator& operator -= (int ofs);
 
     //! reads the next maxCount elements (or less, if the sequence/mapping last element occurs earlier) to the buffer with the specified format
-    FileNodeIterator& readRaw( const std::string& fmt, uchar* vec,
+    FileNodeIterator& readRaw( const cv::String& fmt, uchar* vec,
                                size_t maxCount=(size_t)INT_MAX );
 
     const CvFileStorage* fs;
@@ -4155,41 +4155,41 @@ class CV_EXPORTS_W Algorithm
 public:
     Algorithm();
     virtual ~Algorithm();
-    std::string name() const;
+    cv::String name() const;
 
-    template<typename _Tp> typename ParamType<_Tp>::member_type get(const std::string& name) const;
+    template<typename _Tp> typename ParamType<_Tp>::member_type get(const cv::String& name) const;
     template<typename _Tp> typename ParamType<_Tp>::member_type get(const char* name) const;
 
-    CV_WRAP int getInt(const std::string& name) const;
+    CV_WRAP int getInt(const cv::String& name) const;
-    CV_WRAP double getDouble(const std::string& name) const;
+    CV_WRAP double getDouble(const cv::String& name) const;
-    CV_WRAP bool getBool(const std::string& name) const;
+    CV_WRAP bool getBool(const cv::String& name) const;
-    CV_WRAP std::string getString(const std::string& name) const;
+    CV_WRAP cv::String getString(const cv::String& name) const;
-    CV_WRAP Mat getMat(const std::string& name) const;
+    CV_WRAP Mat getMat(const cv::String& name) const;
-    CV_WRAP std::vector<Mat> getMatVector(const std::string& name) const;
+    CV_WRAP std::vector<Mat> getMatVector(const cv::String& name) const;
-    CV_WRAP Ptr<Algorithm> getAlgorithm(const std::string& name) const;
+    CV_WRAP Ptr<Algorithm> getAlgorithm(const cv::String& name) const;
 
-    void set(const std::string& name, int value);
+    void set(const cv::String& name, int value);
-    void set(const std::string& name, double value);
+    void set(const cv::String& name, double value);
-    void set(const std::string& name, bool value);
+    void set(const cv::String& name, bool value);
-    void set(const std::string& name, const std::string& value);
+    void set(const cv::String& name, const cv::String& value);
-    void set(const std::string& name, const Mat& value);
+    void set(const cv::String& name, const Mat& value);
-    void set(const std::string& name, const std::vector<Mat>& value);
+    void set(const cv::String& name, const std::vector<Mat>& value);
-    void set(const std::string& name, const Ptr<Algorithm>& value);
+    void set(const cv::String& name, const Ptr<Algorithm>& value);
-    template<typename _Tp> void set(const std::string& name, const Ptr<_Tp>& value);
+    template<typename _Tp> void set(const cv::String& name, const Ptr<_Tp>& value);
 
-    CV_WRAP void setInt(const std::string& name, int value);
+    CV_WRAP void setInt(const cv::String& name, int value);
-    CV_WRAP void setDouble(const std::string& name, double value);
+    CV_WRAP void setDouble(const cv::String& name, double value);
-    CV_WRAP void setBool(const std::string& name, bool value);
+    CV_WRAP void setBool(const cv::String& name, bool value);
-    CV_WRAP void setString(const std::string& name, const std::string& value);
+    CV_WRAP void setString(const cv::String& name, const cv::String& value);
-    CV_WRAP void setMat(const std::string& name, const Mat& value);
+    CV_WRAP void setMat(const cv::String& name, const Mat& value);
-    CV_WRAP void setMatVector(const std::string& name, const std::vector<Mat>& value);
+    CV_WRAP void setMatVector(const cv::String& name, const std::vector<Mat>& value);
-    CV_WRAP void setAlgorithm(const std::string& name, const Ptr<Algorithm>& value);
+    CV_WRAP void setAlgorithm(const cv::String& name, const Ptr<Algorithm>& value);
-    template<typename _Tp> void setAlgorithm(const std::string& name, const Ptr<_Tp>& value);
+    template<typename _Tp> void setAlgorithm(const cv::String& name, const Ptr<_Tp>& value);
 
     void set(const char* name, int value);
     void set(const char* name, double value);
     void set(const char* name, bool value);
-    void set(const char* name, const std::string& value);
+    void set(const char* name, const cv::String& value);
     void set(const char* name, const Mat& value);
     void set(const char* name, const std::vector<Mat>& value);
     void set(const char* name, const Ptr<Algorithm>& value);
@@ -4198,16 +4198,16 @@ public:
     void setInt(const char* name, int value);
     void setDouble(const char* name, double value);
     void setBool(const char* name, bool value);
-    void setString(const char* name, const std::string& value);
+    void setString(const char* name, const cv::String& value);
     void setMat(const char* name, const Mat& value);
     void setMatVector(const char* name, const std::vector<Mat>& value);
     void setAlgorithm(const char* name, const Ptr<Algorithm>& value);
     template<typename _Tp> void setAlgorithm(const char* name, const Ptr<_Tp>& value);
 
-    CV_WRAP std::string paramHelp(const std::string& name) const;
+    CV_WRAP cv::String paramHelp(const cv::String& name) const;
     int paramType(const char* name) const;
-    CV_WRAP int paramType(const std::string& name) const;
+    CV_WRAP int paramType(const cv::String& name) const;
-    CV_WRAP void getParams(CV_OUT std::vector<std::string>& names) const;
+    CV_WRAP void getParams(CV_OUT std::vector<cv::String>& names) const;
 
 
     virtual void write(FileStorage& fs) const;
@@ -4217,9 +4217,9 @@ public:
     typedef int (Algorithm::*Getter)() const;
     typedef void (Algorithm::*Setter)(int);
 
-    CV_WRAP static void getList(CV_OUT std::vector<std::string>& algorithms);
+    CV_WRAP static void getList(CV_OUT std::vector<cv::String>& algorithms);
-    CV_WRAP static Ptr<Algorithm> _create(const std::string& name);
+    CV_WRAP static Ptr<Algorithm> _create(const cv::String& name);
-    template<typename _Tp> static Ptr<_Tp> create(const std::string& name);
+    template<typename _Tp> static Ptr<_Tp> create(const cv::String& name);
 
     virtual AlgorithmInfo* info() const /* TODO: make it = 0;*/ { return 0; }
 };
@@ -4229,86 +4229,86 @@ class CV_EXPORTS AlgorithmInfo
 {
 public:
     friend class Algorithm;
-    AlgorithmInfo(const std::string& name, Algorithm::Constructor create);
+    AlgorithmInfo(const cv::String& name, Algorithm::Constructor create);
     ~AlgorithmInfo();
     void get(const Algorithm* algo, const char* name, int argType, void* value) const;
     void addParam_(Algorithm& algo, const char* name, int argType,
                    void* value, bool readOnly,
                    Algorithm::Getter getter, Algorithm::Setter setter,
-                   const std::string& help=std::string());
+                   const cv::String& help=cv::String());
-    std::string paramHelp(const char* name) const;
+    cv::String paramHelp(const char* name) const;
     int paramType(const char* name) const;
-    void getParams(std::vector<std::string>& names) const;
+    void getParams(std::vector<cv::String>& names) const;
 
     void write(const Algorithm* algo, FileStorage& fs) const;
     void read(Algorithm* algo, const FileNode& fn) const;
-    std::string name() const;
+    cv::String name() const;
 
     void addParam(Algorithm& algo, const char* name,
                   int& value, bool readOnly=false,
                   int (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(int)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   bool& value, bool readOnly=false,
                   int (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(int)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   double& value, bool readOnly=false,
                   double (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(double)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
-                  std::string& value, bool readOnly=false,
+                  cv::String& value, bool readOnly=false,
-                  std::string (Algorithm::*getter)()=0,
+                  cv::String (Algorithm::*getter)()=0,
-                  void (Algorithm::*setter)(const std::string&)=0,
+                  void (Algorithm::*setter)(const cv::String&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   Mat& value, bool readOnly=false,
                   Mat (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(const Mat&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   std::vector<Mat>& value, bool readOnly=false,
                   std::vector<Mat> (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(const std::vector<Mat>&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   Ptr<Algorithm>& value, bool readOnly=false,
                   Ptr<Algorithm> (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(const Ptr<Algorithm>&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   float& value, bool readOnly=false,
                   float (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(float)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   unsigned int& value, bool readOnly=false,
                   unsigned int (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(unsigned int)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   uint64& value, bool readOnly=false,
                   uint64 (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(uint64)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     void addParam(Algorithm& algo, const char* name,
                   uchar& value, bool readOnly=false,
                   uchar (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(uchar)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     template<typename _Tp, typename _Base> void addParam(Algorithm& algo, const char* name,
                   Ptr<_Tp>& value, bool readOnly=false,
                   Ptr<_Tp> (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(const Ptr<_Tp>&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
     template<typename _Tp> void addParam(Algorithm& algo, const char* name,
                   Ptr<_Tp>& value, bool readOnly=false,
                   Ptr<_Tp> (Algorithm::*getter)()=0,
                   void (Algorithm::*setter)(const Ptr<_Tp>&)=0,
-                  const std::string& help=std::string());
+                  const cv::String& help=cv::String());
 protected:
     AlgorithmInfoData* data;
     void set(Algorithm* algo, const char* name, int argType,
@@ -4324,13 +4324,13 @@ struct CV_EXPORTS Param
     Param(int _type, bool _readonly, int _offset,
           Algorithm::Getter _getter=0,
           Algorithm::Setter _setter=0,
-          const std::string& _help=std::string());
+          const cv::String& _help=cv::String());
     int type;
     int offset;
     bool readonly;
     Algorithm::Getter getter;
     Algorithm::Setter setter;
-    std::string help;
+    cv::String help;
 };
 
 template<> struct ParamType<bool>
@@ -4357,10 +4357,10 @@ template<> struct ParamType<double>
     enum { type = Param::REAL };
 };
 
-template<> struct ParamType<std::string>
+template<> struct ParamType<cv::String>
 {
-    typedef const std::string& const_param_type;
+    typedef const cv::String& const_param_type;
-    typedef std::string member_type;
+    typedef cv::String member_type;
 
     enum { type = Param::STRING };
 };

modules/core/include/opencv2/core/gpumat.hpp

@@ -247,7 +247,7 @@ namespace cv { namespace gpu
         // Creates DeviceInfo object for the given GPU
         DeviceInfo(int device_id) : device_id_(device_id) { query(); }
 
-        std::string name() const { return name_; }
+        cv::String name() const { return name_; }
 
         // Return compute capability versions
         int majorVersion() const { return majorVersion_; }
@@ -274,7 +274,7 @@ namespace cv { namespace gpu
 
         int device_id_;
 
-        std::string name_;
+        cv::String name_;
         int multi_processor_count_;
         int majorVersion_;
         int minorVersion_;

modules/core/include/opencv2/core/operations.hpp

@@ -2611,18 +2611,18 @@ template<> CV_EXPORTS void Ptr<CvFileStorage>::delete_obj();
 
 //////////////////////////////////////// XML & YAML I/O ////////////////////////////////////
 
-CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, int value );
+CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, int value );
-CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, float value );
+CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, float value );
-CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, double value );
+CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, double value );
-CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, const std::string& value );
+CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, const cv::String& value );
 
 template<typename _Tp> inline void write(FileStorage& fs, const _Tp& value)
-{ write(fs, std::string(), value); }
+{ write(fs, cv::String(), value); }
 
 CV_EXPORTS void writeScalar( FileStorage& fs, int value );
 CV_EXPORTS void writeScalar( FileStorage& fs, float value );
 CV_EXPORTS void writeScalar( FileStorage& fs, double value );
-CV_EXPORTS void writeScalar( FileStorage& fs, const std::string& value );
+CV_EXPORTS void writeScalar( FileStorage& fs, const cv::String& value );
 
 template<> inline void write( FileStorage& fs, const int& value )
 {
@@ -2639,7 +2639,7 @@ template<> inline void write( FileStorage& fs, const double& value )
     writeScalar(fs, value);
 }
 
-template<> inline void write( FileStorage& fs, const std::string& value )
+template<> inline void write( FileStorage& fs, const cv::String& value )
 {
     writeScalar(fs, value);
 }
@@ -2700,20 +2700,20 @@ inline void write(FileStorage& fs, const Range& r )
 class CV_EXPORTS WriteStructContext
 {
 public:
-    WriteStructContext(FileStorage& _fs, const std::string& name,
+    WriteStructContext(FileStorage& _fs, const cv::String& name,
-        int flags, const std::string& typeName=std::string());
+        int flags, const cv::String& typeName=cv::String());
     ~WriteStructContext();
     FileStorage* fs;
 };
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Point_<_Tp>& pt )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Point_<_Tp>& pt )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, pt.x);
     write(fs, pt.y);
 }
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Point3_<_Tp>& pt )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Point3_<_Tp>& pt )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, pt.x);
@@ -2721,21 +2721,21 @@ template<typename _Tp> inline void write(FileStorage& fs, const std::string& nam
     write(fs, pt.z);
 }
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Size_<_Tp>& sz )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Size_<_Tp>& sz )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, sz.width);
     write(fs, sz.height);
 }
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Complex<_Tp>& c )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Complex<_Tp>& c )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, c.re);
     write(fs, c.im);
 }
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Rect_<_Tp>& r )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Rect_<_Tp>& r )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, r.x);
@@ -2744,14 +2744,14 @@ template<typename _Tp> inline void write(FileStorage& fs, const std::string& nam
     write(fs, r.height);
 }
 
-template<typename _Tp, int cn> inline void write(FileStorage& fs, const std::string& name, const Vec<_Tp, cn>& v )
+template<typename _Tp, int cn> inline void write(FileStorage& fs, const cv::String& name, const Vec<_Tp, cn>& v )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     for(int i = 0; i < cn; i++)
         write(fs, v.val[i]);
 }
 
-template<typename _Tp> inline void write(FileStorage& fs, const std::string& name, const Scalar_<_Tp>& s )
+template<typename _Tp> inline void write(FileStorage& fs, const cv::String& name, const Scalar_<_Tp>& s )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, s.val[0]);
@@ -2760,7 +2760,7 @@ template<typename _Tp> inline void write(FileStorage& fs, const std::string& nam
     write(fs, s.val[3]);
 }
 
-inline void write(FileStorage& fs, const std::string& name, const Range& r )
+inline void write(FileStorage& fs, const cv::String& name, const Range& r )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
     write(fs, r.start);
@@ -2788,7 +2788,7 @@ public:
     {
         int _fmt = DataType<_Tp>::fmt;
         char fmt[] = { (char)((_fmt>>8)+'1'), (char)_fmt, '\0' };
-        fs->writeRaw( std::string(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, vec.size()*sizeof(_Tp) );
+        fs->writeRaw( cv::String(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, vec.size()*sizeof(_Tp) );
     }
     FileStorage* fs;
 };
@@ -2799,15 +2799,15 @@ template<typename _Tp> static inline void write( FileStorage& fs, const std::vec
     w(vec);
 }
 
-template<typename _Tp> static inline void write( FileStorage& fs, const std::string& name,
+template<typename _Tp> static inline void write( FileStorage& fs, const cv::String& name,
                                                 const std::vector<_Tp>& vec )
 {
     WriteStructContext ws(fs, name, CV_NODE_SEQ+(DataType<_Tp>::fmt != 0 ? CV_NODE_FLOW : 0));
     write(fs, vec);
 }
 
-CV_EXPORTS_W void write( FileStorage& fs, const std::string& name, const Mat& value );
+CV_EXPORTS_W void write( FileStorage& fs, const cv::String& name, const Mat& value );
-CV_EXPORTS void write( FileStorage& fs, const std::string& name, const SparseMat& value );
+CV_EXPORTS void write( FileStorage& fs, const cv::String& name, const SparseMat& value );
 
 template<typename _Tp> static inline FileStorage& operator << (FileStorage& fs, const _Tp& value)
 {
@@ -2821,10 +2821,10 @@ template<typename _Tp> static inline FileStorage& operator << (FileStorage& fs,
     return fs;
 }
 
-CV_EXPORTS FileStorage& operator << (FileStorage& fs, const std::string& str);
+CV_EXPORTS FileStorage& operator << (FileStorage& fs, const cv::String& str);
 
 static inline FileStorage& operator << (FileStorage& fs, const char* str)
-{ return (fs << std::string(str)); }
+{ return (fs << cv::String(str)); }
 
 inline FileNode::FileNode() : fs(0), node(0) {}
 inline FileNode::FileNode(const CvFileStorage* _fs, const CvFileNode* _node)
@@ -2928,9 +2928,9 @@ inline FileNode::operator double() const
     read(*this, value, 0.);
     return value;
 }
-inline FileNode::operator std::string() const
+inline FileNode::operator cv::String() const
 {
-    std::string value;
+    cv::String value;
     read(*this, value, value);
     return value;
 }
@@ -2971,7 +2971,7 @@ public:
         size_t remaining1 = remaining/cn;
         count = count < remaining1 ? count : remaining1;
         vec.resize(count);
-        it->readRaw( std::string(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, count*sizeof(_Tp) );
+        it->readRaw( cv::String(fmt), !vec.empty() ? (uchar*)&vec[0] : 0, count*sizeof(_Tp) );
     }
     FileNodeIterator* it;
 };
@@ -3662,7 +3662,7 @@ public:
         {
             FileStorage fs(_fs);
             fs.fs.addref();
-            ((const _ClsName*)ptr)->write(fs, std::string(name));
+            ((const _ClsName*)ptr)->write(fs, cv::String(name));
         }
     }
 
@@ -3824,7 +3824,7 @@ template<typename _Tp> inline std::ostream& operator<<(std::ostream& out, const
 }
 
 
-template<typename _Tp> inline Ptr<_Tp> Algorithm::create(const std::string& name)
+template<typename _Tp> inline Ptr<_Tp> Algorithm::create(const cv::String& name)
 {
     return _create(name).ptr<_Tp>();
 }
@@ -3840,7 +3840,7 @@ inline void Algorithm::set(const char* _name, const Ptr<_Tp>& value)
 }
 
 template<typename _Tp>
-inline void Algorithm::set(const std::string& _name, const Ptr<_Tp>& value)
+inline void Algorithm::set(const cv::String& _name, const Ptr<_Tp>& value)
 {
     this->set<_Tp>(_name.c_str(), value);
 }
@@ -3856,12 +3856,12 @@ inline void Algorithm::setAlgorithm(const char* _name, const Ptr<_Tp>& value)
 }
 
 template<typename _Tp>
-inline void Algorithm::setAlgorithm(const std::string& _name, const Ptr<_Tp>& value)
+inline void Algorithm::setAlgorithm(const cv::String& _name, const Ptr<_Tp>& value)
 {
     this->set<_Tp>(_name.c_str(), value);
 }
 
-template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const std::string& _name) const
+template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const cv::String& _name) const
 {
     typename ParamType<_Tp>::member_type value;
     info()->get(this, _name.c_str(), ParamType<_Tp>::type, &value);
@@ -3877,7 +3877,7 @@ template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::ge
 
 template<typename _Tp, typename _Base> inline void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                   Ptr<_Tp>& value, bool readOnly, Ptr<_Tp> (Algorithm::*getter)(), void (Algorithm::*setter)(const Ptr<_Tp>&),
-                  const std::string& help)
+                  const cv::String& help)
 {
     //TODO: static assert: _Tp inherits from _Base
     addParam_(algo, parameter, ParamType<_Base>::type, &value, readOnly,
@@ -3886,7 +3886,7 @@ template<typename _Tp, typename _Base> inline void AlgorithmInfo::addParam(Algor
 
 template<typename _Tp> inline void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                   Ptr<_Tp>& value, bool readOnly, Ptr<_Tp> (Algorithm::*getter)(), void (Algorithm::*setter)(const Ptr<_Tp>&),
-                  const std::string& help)
+                  const cv::String& help)
 {
     //TODO: static assert: _Tp inherits from Algorithm
     addParam_(algo, parameter, ParamType<Algorithm>::type, &value, readOnly,

modules/core/src/algorithm.cpp

@@ -96,7 +96,7 @@ template<typename _KeyTp, typename _ValueTp> struct sorted_vector
 };
 
 
-template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<std::string, _ValueTp>& vec,
+template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<cv::String, _ValueTp>& vec,
                                                            const char* key)
 {
     if( !key )
@@ -130,7 +130,7 @@ Param::Param()
 
 Param::Param(int _type, bool _readonly, int _offset,
              Algorithm::Getter _getter, Algorithm::Setter _setter,
-             const std::string& _help)
+             const cv::String& _help)
 {
     type = _type;
     readonly = _readonly;
@@ -142,23 +142,23 @@ Param::Param(int _type, bool _readonly, int _offset,
 
 struct CV_EXPORTS AlgorithmInfoData
 {
-    sorted_vector<std::string, Param> params;
+    sorted_vector<cv::String, Param> params;
-    std::string _name;
+    cv::String _name;
 };
 
 
-static sorted_vector<std::string, Algorithm::Constructor>& alglist()
+static sorted_vector<cv::String, Algorithm::Constructor>& alglist()
 {
-    static sorted_vector<std::string, Algorithm::Constructor> alglist_var;
+    static sorted_vector<cv::String, Algorithm::Constructor> alglist_var;
     return alglist_var;
 }
 
-void Algorithm::getList(std::vector<std::string>& algorithms)
+void Algorithm::getList(std::vector<cv::String>& algorithms)
 {
     alglist().get_keys(algorithms);
 }
 
-Ptr<Algorithm> Algorithm::_create(const std::string& name)
+Ptr<Algorithm> Algorithm::_create(const cv::String& name)
 {
     Algorithm::Constructor c = 0;
     if( !alglist().find(name, c) )
@@ -174,42 +174,42 @@ Algorithm::~Algorithm()
 {
 }
 
-std::string Algorithm::name() const
+cv::String Algorithm::name() const
 {
     return info()->name();
 }
 
-void Algorithm::set(const std::string& parameter, int value)
+void Algorithm::set(const cv::String& parameter, int value)
 {
     info()->set(this, parameter.c_str(), ParamType<int>::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, double value)
+void Algorithm::set(const cv::String& parameter, double value)
 {
     info()->set(this, parameter.c_str(), ParamType<double>::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, bool value)
+void Algorithm::set(const cv::String& parameter, bool value)
 {
     info()->set(this, parameter.c_str(), ParamType<bool>::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, const std::string& value)
+void Algorithm::set(const cv::String& parameter, const cv::String& value)
 {
-    info()->set(this, parameter.c_str(), ParamType<std::string>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<cv::String>::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, const Mat& value)
+void Algorithm::set(const cv::String& parameter, const Mat& value)
 {
     info()->set(this, parameter.c_str(), ParamType<Mat>::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, const std::vector<Mat>& value)
+void Algorithm::set(const cv::String& parameter, const std::vector<Mat>& value)
 {
     info()->set(this, parameter.c_str(), ParamType<std::vector<Mat> >::type, &value);
 }
 
-void Algorithm::set(const std::string& parameter, const Ptr<Algorithm>& value)
+void Algorithm::set(const cv::String& parameter, const Ptr<Algorithm>& value)
 {
     info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
 }
@@ -229,9 +229,9 @@ void Algorithm::set(const char* parameter, bool value)
     info()->set(this, parameter, ParamType<bool>::type, &value);
 }
 
-void Algorithm::set(const char* parameter, const std::string& value)
+void Algorithm::set(const char* parameter, const cv::String& value)
 {
-    info()->set(this, parameter, ParamType<std::string>::type, &value);
+    info()->set(this, parameter, ParamType<cv::String>::type, &value);
 }
 
 void Algorithm::set(const char* parameter, const Mat& value)
@@ -250,37 +250,37 @@ void Algorithm::set(const char* parameter, const Ptr<Algorithm>& value)
 }
 
 
-void Algorithm::setInt(const std::string& parameter, int value)
+void Algorithm::setInt(const cv::String& parameter, int value)
 {
     info()->set(this, parameter.c_str(), ParamType<int>::type, &value);
 }
 
-void Algorithm::setDouble(const std::string& parameter, double value)
+void Algorithm::setDouble(const cv::String& parameter, double value)
 {
     info()->set(this, parameter.c_str(), ParamType<double>::type, &value);
 }
 
-void Algorithm::setBool(const std::string& parameter, bool value)
+void Algorithm::setBool(const cv::String& parameter, bool value)
 {
     info()->set(this, parameter.c_str(), ParamType<bool>::type, &value);
 }
 
-void Algorithm::setString(const std::string& parameter, const std::string& value)
+void Algorithm::setString(const cv::String& parameter, const cv::String& value)
 {
-    info()->set(this, parameter.c_str(), ParamType<std::string>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<cv::String>::type, &value);
 }
 
-void Algorithm::setMat(const std::string& parameter, const Mat& value)
+void Algorithm::setMat(const cv::String& parameter, const Mat& value)
 {
     info()->set(this, parameter.c_str(), ParamType<Mat>::type, &value);
 }
 
-void Algorithm::setMatVector(const std::string& parameter, const std::vector<Mat>& value)
+void Algorithm::setMatVector(const cv::String& parameter, const std::vector<Mat>& value)
 {
     info()->set(this, parameter.c_str(), ParamType<std::vector<Mat> >::type, &value);
 }
 
-void Algorithm::setAlgorithm(const std::string& parameter, const Ptr<Algorithm>& value)
+void Algorithm::setAlgorithm(const cv::String& parameter, const Ptr<Algorithm>& value)
 {
     info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
 }
@@ -300,9 +300,9 @@ void Algorithm::setBool(const char* parameter, bool value)
     info()->set(this, parameter, ParamType<bool>::type, &value);
 }
 
-void Algorithm::setString(const char* parameter, const std::string& value)
+void Algorithm::setString(const char* parameter, const cv::String& value)
 {
-    info()->set(this, parameter, ParamType<std::string>::type, &value);
+    info()->set(this, parameter, ParamType<cv::String>::type, &value);
 }
 
 void Algorithm::setMat(const char* parameter, const Mat& value)
@@ -322,47 +322,47 @@ void Algorithm::setAlgorithm(const char* parameter, const Ptr<Algorithm>& value)
 
 
 
-int Algorithm::getInt(const std::string& parameter) const
+int Algorithm::getInt(const cv::String& parameter) const
 {
     return get<int>(parameter);
 }
 
-double Algorithm::getDouble(const std::string& parameter) const
+double Algorithm::getDouble(const cv::String& parameter) const
 {
     return get<double>(parameter);
 }
 
-bool Algorithm::getBool(const std::string& parameter) const
+bool Algorithm::getBool(const cv::String& parameter) const
 {
     return get<bool>(parameter);
 }
 
-std::string Algorithm::getString(const std::string& parameter) const
+cv::String Algorithm::getString(const cv::String& parameter) const
 {
-    return get<std::string>(parameter);
+    return get<cv::String>(parameter);
 }
 
-Mat Algorithm::getMat(const std::string& parameter) const
+Mat Algorithm::getMat(const cv::String& parameter) const
 {
     return get<Mat>(parameter);
 }
 
-std::vector<Mat> Algorithm::getMatVector(const std::string& parameter) const
+std::vector<Mat> Algorithm::getMatVector(const cv::String& parameter) const
 {
     return get<std::vector<Mat> >(parameter);
 }
 
-Ptr<Algorithm> Algorithm::getAlgorithm(const std::string& parameter) const
+Ptr<Algorithm> Algorithm::getAlgorithm(const cv::String& parameter) const
 {
     return get<Algorithm>(parameter);
 }
 
-std::string Algorithm::paramHelp(const std::string& parameter) const
+cv::String Algorithm::paramHelp(const cv::String& parameter) const
 {
     return info()->paramHelp(parameter.c_str());
 }
 
-int Algorithm::paramType(const std::string& parameter) const
+int Algorithm::paramType(const cv::String& parameter) const
 {
     return info()->paramType(parameter.c_str());
 }
@@ -372,7 +372,7 @@ int Algorithm::paramType(const char* parameter) const
     return info()->paramType(parameter);
 }
 
-void Algorithm::getParams(std::vector<std::string>& names) const
+void Algorithm::getParams(std::vector<cv::String>& names) const
 {
     info()->getParams(names);
 }
@@ -388,7 +388,7 @@ void Algorithm::read(const FileNode& fn)
 }
 
 
-AlgorithmInfo::AlgorithmInfo(const std::string& _name, Algorithm::Constructor create)
+AlgorithmInfo::AlgorithmInfo(const cv::String& _name, Algorithm::Constructor create)
 {
     data = new AlgorithmInfoData;
     data->_name = _name;
@@ -408,7 +408,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const
     for( i = 0; i < nparams; i++ )
     {
         const Param& p = data->params.vec[i].second;
-        const std::string& pname = data->params.vec[i].first;
+        const cv::String& pname = data->params.vec[i].first;
         if( p.type == Param::INT )
             cv::write(fs, pname, algo->get<int>(pname));
         else if( p.type == Param::BOOLEAN )
@@ -416,7 +416,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const
         else if( p.type == Param::REAL )
             cv::write(fs, pname, algo->get<double>(pname));
         else if( p.type == Param::STRING )
-            cv::write(fs, pname, algo->get<std::string>(pname));
+            cv::write(fs, pname, algo->get<cv::String>(pname));
         else if( p.type == Param::MAT )
             cv::write(fs, pname, algo->get<Mat>(pname));
         else if( p.type == Param::MAT_VECTOR )
@@ -437,7 +437,7 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const
             cv::write(fs, pname, algo->getInt(pname));
         else
         {
-            std::string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
+            cv::String msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
             CV_Error( CV_StsUnsupportedFormat, msg.c_str());
         }
     }
@@ -451,7 +451,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
     for( i = 0; i < nparams; i++ )
     {
         const Param& p = data->params.vec[i].second;
-        const std::string& pname = data->params.vec[i].first;
+        const cv::String& pname = data->params.vec[i].first;
         const FileNode n = fn[pname];
         if( n.empty() )
             continue;
@@ -472,7 +472,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
         }
         else if( p.type == Param::STRING )
         {
-            std::string val = (std::string)n;
+            cv::String val = (cv::String)n;
             info->set(algo, pname.c_str(), p.type, &val, true);
         }
         else if( p.type == Param::MAT )
@@ -489,7 +489,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
         }
         else if( p.type == Param::ALGORITHM )
         {
-            Ptr<Algorithm> nestedAlgo = Algorithm::_create((std::string)n["name"]);
+            Ptr<Algorithm> nestedAlgo = Algorithm::_create((cv::String)n["name"]);
             CV_Assert( !nestedAlgo.empty() );
             nestedAlgo->read(n);
             info->set(algo, pname.c_str(), p.type, &nestedAlgo, true);
@@ -516,13 +516,13 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
         }
         else
         {
-            std::string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
+            cv::String msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
             CV_Error( CV_StsUnsupportedFormat, msg.c_str());
         }
     }
 }
 
-std::string AlgorithmInfo::name() const
+cv::String AlgorithmInfo::name() const
 {
     return data->_name;
 }
@@ -532,7 +532,7 @@ union GetSetParam
     int (Algorithm::*get_int)() const;
     bool (Algorithm::*get_bool)() const;
     double (Algorithm::*get_double)() const;
-    std::string (Algorithm::*get_string)() const;
+    cv::String (Algorithm::*get_string)() const;
     Mat (Algorithm::*get_mat)() const;
     std::vector<Mat> (Algorithm::*get_mat_vector)() const;
     Ptr<Algorithm> (Algorithm::*get_algo)() const;
@@ -544,7 +544,7 @@ union GetSetParam
     void (Algorithm::*set_int)(int);
     void (Algorithm::*set_bool)(bool);
     void (Algorithm::*set_double)(double);
-    void (Algorithm::*set_string)(const std::string&);
+    void (Algorithm::*set_string)(const cv::String&);
     void (Algorithm::*set_mat)(const Mat&);
     void (Algorithm::*set_mat_vector)(const std::vector<Mat>&);
     void (Algorithm::*set_algo)(const Ptr<Algorithm>&);
@@ -554,9 +554,9 @@ union GetSetParam
     void (Algorithm::*set_uchar)(uchar);
 };
 
-static std::string getNameOfType(int argType);
+static cv::String getNameOfType(int argType);
 
-static std::string getNameOfType(int argType)
+static cv::String getNameOfType(int argType)
 {
     switch(argType)
     {
@@ -576,37 +576,37 @@ static std::string getNameOfType(int argType)
     return "";
 }
 
-static std::string getErrorMessageForWrongArgumentInSetter(std::string algoName, std::string paramName, int paramType, int argType)
+static cv::String getErrorMessageForWrongArgumentInSetter(cv::String algoName, cv::String paramName, int paramType, int argType)
 {
-    std::string message = std::string("Argument error: the setter")
+    cv::String message = cv::String("Argument error: the setter")
         + " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName
         +"', the parameter has " + getNameOfType(paramType) + " type, ";
 
     if (paramType == Param::INT || paramType == Param::BOOLEAN || paramType == Param::REAL
             || paramType == Param::FLOAT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR)
     {
-        message += "so it should be set by integer, unsigned integer, uint64, unsigned char, boolean, float or double value, ";
+        message = message + "so it should be set by integer, unsigned integer, uint64, unsigned char, boolean, float or double value, ";
     }
-    message += "but the setter was called with " + getNameOfType(argType) + " value";
+    message = message + "but the setter was called with " + getNameOfType(argType) + " value";
 
     return message;
 }
 
-static std::string getErrorMessageForWrongArgumentInGetter(std::string algoName, std::string paramName, int paramType, int argType)
+static cv::String getErrorMessageForWrongArgumentInGetter(cv::String algoName, cv::String paramName, int paramType, int argType)
 {
-    std::string message = std::string("Argument error: the getter")
+    cv::String message = cv::String("Argument error: the getter")
         + " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName
         +"', the parameter has " + getNameOfType(paramType) + " type, ";
 
     if (paramType == Param::BOOLEAN)
     {
-        message += "so it should be get as integer, unsigned integer, uint64, boolean, unsigned char, float or double value, ";
+        message = message + "so it should be get as integer, unsigned integer, uint64, boolean, unsigned char, float or double value, ";
     }
     else if (paramType == Param::INT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR)
     {
-        message += "so it should be get as integer, unsigned integer, uint64, unsigned char, float or double value, ";
+        message = message + "so it should be get as integer, unsigned integer, uint64, unsigned char, float or double value, ";
     }
-    message += "but the getter was called to get a " + getNameOfType(argType) + " value";
+    message = message + "but the getter was called to get a " + getNameOfType(argType) + " value";
 
     return message;
 }
@@ -630,7 +630,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
         if ( !( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN
                 || p->type == Param::UNSIGNED_INT || p->type == Param::UINT64 || p->type == Param::FLOAT || argType == Param::UCHAR) )
         {
-            std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -790,21 +790,21 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
     {
         if( p->type != Param::STRING )
         {
-            std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
-        const std::string& val = *(const std::string*)value;
+        const cv::String& val = *(const cv::String*)value;
         if( p->setter )
             (algo->*f.set_string)(val);
         else
-            *(std::string*)((uchar*)algo + p->offset) = val;
+            *(cv::String*)((uchar*)algo + p->offset) = val;
     }
     else if( argType == Param::MAT )
     {
         if( p->type != Param::MAT )
         {
-            std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -818,7 +818,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
     {
         if( p->type != Param::MAT_VECTOR )
         {
-            std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -832,7 +832,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
     {
         if( p->type != Param::ALGORITHM )
         {
-            std::string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -862,7 +862,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset);
@@ -887,7 +887,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if (!( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             bool val = p->getter ? (algo->*f.get_bool)() : *(bool*)((uchar*)algo + p->offset);
@@ -913,7 +913,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if(!( argType == Param::REAL || argType == Param::FLOAT))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             double val = p->getter ? (algo->*f.get_double)() : *(double*)((uchar*)algo + p->offset);
@@ -929,7 +929,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if(!( argType == Param::REAL || argType == Param::FLOAT))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             float val = p->getter ? (algo->*f.get_float)() : *(float*)((uchar*)algo + p->offset);
@@ -945,7 +945,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             unsigned int val = p->getter ? (algo->*f.get_uint)() : *(unsigned int*)((uchar*)algo + p->offset);
@@ -969,7 +969,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
         }
             uint64 val = p->getter ? (algo->*f.get_uint64)() : *(uint64*)((uchar*)algo + p->offset);
@@ -993,7 +993,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
         {
             if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
             {
-                std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+                cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
                 CV_Error(CV_StsBadArg, message);
             }
             uchar val = p->getter ? (algo->*f.get_uchar)() : *(uchar*)((uchar*)algo + p->offset);
@@ -1021,18 +1021,18 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
     {
         if( p->type != Param::STRING )
         {
-            std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
-        *(std::string*)value = p->getter ? (algo->*f.get_string)() :
+        *(cv::String*)value = p->getter ? (algo->*f.get_string)() :
-            *(std::string*)((uchar*)algo + p->offset);
+            *(cv::String*)((uchar*)algo + p->offset);
     }
     else if( argType == Param::MAT )
     {
         if( p->type != Param::MAT )
         {
-            std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -1043,7 +1043,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
     {
         if( p->type != Param::MAT_VECTOR )
         {
-            std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -1054,7 +1054,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
     {
         if( p->type != Param::ALGORITHM )
         {
-            std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+            cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
             CV_Error(CV_StsBadArg, message);
         }
 
@@ -1063,7 +1063,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
     }
     else
     {
-        std::string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
+        cv::String message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
         CV_Error(CV_StsBadArg, message);
     }
 }
@@ -1078,7 +1078,7 @@ int AlgorithmInfo::paramType(const char* parameter) const
 }
 
 
-std::string AlgorithmInfo::paramHelp(const char* parameter) const
+cv::String AlgorithmInfo::paramHelp(const char* parameter) const
 {
     const Param* p = findstr(data->params, parameter);
     if( !p )
@@ -1087,7 +1087,7 @@ std::string AlgorithmInfo::paramHelp(const char* parameter) const
 }
 
 
-void AlgorithmInfo::getParams(std::vector<std::string>& names) const
+void AlgorithmInfo::getParams(std::vector<cv::String>& names) const
 {
     data->params.get_keys(names);
 }
@@ -1096,7 +1096,7 @@ void AlgorithmInfo::getParams(std::vector<std::string>& names) const
 void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argType,
                               void* value, bool readOnly,
                               Algorithm::Getter getter, Algorithm::Setter setter,
-                              const std::string& help)
+                              const cv::String& help)
 {
     CV_Assert( argType == Param::INT || argType == Param::BOOLEAN ||
                argType == Param::REAL || argType == Param::STRING ||
@@ -1104,7 +1104,7 @@ void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argTyp
                argType == Param::ALGORITHM
                || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64
                || argType == Param::UCHAR);
-    data->params.add(std::string(parameter), Param(argType, readOnly,
+    data->params.add(cv::String(parameter), Param(argType, readOnly,
                      (int)((size_t)value - (size_t)(void*)&algo),
                      getter, setter, help));
 }
@@ -1114,7 +1114,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              int& value, bool readOnly,
                              int (Algorithm::*getter)(),
                              void (Algorithm::*setter)(int),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<int>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1124,7 +1124,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              bool& value, bool readOnly,
                              int (Algorithm::*getter)(),
                              void (Algorithm::*setter)(int),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<bool>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1134,19 +1134,19 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              double& value, bool readOnly,
                              double (Algorithm::*getter)(),
                              void (Algorithm::*setter)(double),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<double>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
 void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
-                             std::string& value, bool readOnly,
+                             cv::String& value, bool readOnly,
-                             std::string (Algorithm::*getter)(),
+                             cv::String (Algorithm::*getter)(),
-                             void (Algorithm::*setter)(const std::string&),
+                             void (Algorithm::*setter)(const cv::String&),
-                             const std::string& help)
+                             const cv::String& help)
 {
-    addParam_(algo, parameter, ParamType<std::string>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<cv::String>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
@@ -1154,7 +1154,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              Mat& value, bool readOnly,
                              Mat (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const Mat&),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<Mat>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1164,7 +1164,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              std::vector<Mat>& value, bool readOnly,
                              std::vector<Mat> (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const std::vector<Mat>&),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<std::vector<Mat> >::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1174,7 +1174,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              Ptr<Algorithm>& value, bool readOnly,
                              Ptr<Algorithm> (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const Ptr<Algorithm>&),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<Algorithm>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1184,7 +1184,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              float& value, bool readOnly,
                              float (Algorithm::*getter)(),
                              void (Algorithm::*setter)(float),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<float>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1194,7 +1194,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              unsigned int& value, bool readOnly,
                              unsigned int (Algorithm::*getter)(),
                              void (Algorithm::*setter)(unsigned int),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<unsigned int>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1204,7 +1204,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              uint64& value, bool readOnly,
                              uint64 (Algorithm::*getter)(),
                              void (Algorithm::*setter)(uint64),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<uint64>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
@@ -1214,7 +1214,7 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              uchar& value, bool readOnly,
                              uchar (Algorithm::*getter)(),
                              void (Algorithm::*setter)(uchar),
-                             const std::string& help)
+                             const cv::String& help)
 {
     addParam_(algo, parameter, ParamType<uchar>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);

modules/core/src/command_line_parser.cpp

@@ -1,17 +1,14 @@
-
 #include "precomp.hpp"
 
-#include <iostream>
-
 namespace cv
 {
 
 struct CommandLineParserParams
 {
 public:
-    std::string help_message;
+    cv::String help_message;
-    std::string def_value;
+    cv::String def_value;
-    std::vector<std::string> keys;
+    std::vector<cv::String> keys;
     int number;
 };
 
@@ -19,27 +16,27 @@ public:
 struct CommandLineParser::Impl
 {
     bool error;
-    std::string error_message;
+    cv::String error_message;
-    std::string about_message;
+    cv::String about_message;
 
-    std::string path_to_app;
+    cv::String path_to_app;
-    std::string app_name;
+    cv::String app_name;
 
     std::vector<CommandLineParserParams> data;
 
-    std::vector<std::string> split_range_string(const std::string& str, char fs, char ss) const;
+    std::vector<cv::String> split_range_string(const cv::String& str, char fs, char ss) const;
-    std::vector<std::string> split_string(const std::string& str, char symbol = ' ', bool create_empty_item = false) const;
+    std::vector<cv::String> split_string(const cv::String& str, char symbol = ' ', bool create_empty_item = false) const;
-    std::string cat_string(const std::string& str) const;
+    cv::String cat_string(const cv::String& str) const;
 
-    void apply_params(const std::string& key, const std::string& value);
+    void apply_params(const cv::String& key, const cv::String& value);
-    void apply_params(int i, std::string value);
+    void apply_params(int i, cv::String value);
 
     void sort_params();
     int refcount;
 };
 
 
-static std::string get_type_name(int type)
+static cv::String get_type_name(int type)
 {
     if( type == Param::INT )
         return "int";
@@ -56,9 +53,9 @@ static std::string get_type_name(int type)
     return "unknown";
 }
 
-static void from_str(const std::string& str, int type, void* dst)
+static void from_str(const cv::String& str, int type, void* dst)
 {
-    std::stringstream ss(str);
+    std::stringstream ss(str.c_str());
     if( type == Param::INT )
         ss >> *(int*)dst;
     else if( type == Param::UNSIGNED_INT )
@@ -70,20 +67,20 @@ static void from_str(const std::string& str, int type, void* dst)
     else if( type == Param::REAL )
         ss >> *(double*)dst;
     else if( type == Param::STRING )
-        *(std::string*)dst = str;
+        *(cv::String*)dst = str;
     else
         throw cv::Exception(CV_StsBadArg, "unknown/unsupported parameter type", "", __FILE__, __LINE__);
 
     if (ss.fail())
     {
-        std::string err_msg = "can not convert: [" + str +
+        cv::String err_msg = "can not convert: [" + str +
         + "] to [" + get_type_name(type) + "]";
 
         throw cv::Exception(CV_StsBadArg, err_msg, "", __FILE__, __LINE__);
     }
 }
 
-void CommandLineParser::getByName(const std::string& name, bool space_delete, int type, void* dst) const
+void CommandLineParser::getByName(const cv::String& name, bool space_delete, int type, void* dst) const
 {
     try
     {
@@ -93,7 +90,7 @@ void CommandLineParser::getByName(const std::string& name, bool space_delete, in
             {
                 if (name.compare(impl->data[i].keys[j]) == 0)
                 {
-                    std::string v = impl->data[i].def_value;
+                    cv::String v = impl->data[i].def_value;
                     if (space_delete)
                         v = impl->cat_string(v);
                     from_str(v, type, dst);
@@ -102,12 +99,12 @@ void CommandLineParser::getByName(const std::string& name, bool space_delete, in
             }
         }
         impl->error = true;
-        impl->error_message += "Unknown parametes " + name + "\n";
+        impl->error_message = impl->error_message + "Unknown parametes " + name + "\n";
     }
     catch (std::exception& e)
     {
         impl->error = true;
-        impl->error_message += "Exception: " + std::string(e.what()) + "\n";
+        impl->error_message = impl->error_message + "Exception: " + cv::String(e.what()) + "\n";
     }
 }
 
@@ -120,19 +117,19 @@ void CommandLineParser::getByIndex(int index, bool space_delete, int type, void*
         {
             if (impl->data[i].number == index)
             {
-                std::string v = impl->data[i].def_value;
+                cv::String v = impl->data[i].def_value;
                 if (space_delete == true) v = impl->cat_string(v);
                 from_str(v, type, dst);
                 return;
             }
         }
         impl->error = true;
-        impl->error_message += "Unknown parametes #" + format("%d", index) + "\n";
+        impl->error_message = impl->error_message + "Unknown parametes #" + format("%d", index) + "\n";
     }
     catch(std::exception & e)
     {
         impl->error = true;
-        impl->error_message += "Exception: " + std::string(e.what()) + "\n";
+        impl->error_message = impl->error_message + "Exception: " + cv::String(e.what()) + "\n";
     }
 }
 
@@ -152,34 +149,34 @@ static bool cmp_params(const CommandLineParserParams & p1, const CommandLinePars
     return true;
 }
 
-CommandLineParser::CommandLineParser(int argc, const char* const argv[], const std::string& keys)
+CommandLineParser::CommandLineParser(int argc, const char* const argv[], const cv::String& keys)
 {
     impl = new Impl;
     impl->refcount = 1;
 
     // path to application
-    size_t pos_s = std::string(argv[0]).find_last_of("/\\");
+    size_t pos_s = cv::String(argv[0]).find_last_of("/\\");
-    if (pos_s == std::string::npos)
+    if (pos_s == cv::String::npos)
     {
         impl->path_to_app = "";
-        impl->app_name = std::string(argv[0]);
+        impl->app_name = cv::String(argv[0]);
     }
     else
     {
-        impl->path_to_app = std::string(argv[0]).substr(0, pos_s);
+        impl->path_to_app = cv::String(argv[0]).substr(0, pos_s);
-        impl->app_name = std::string(argv[0]).substr(pos_s + 1, std::string(argv[0]).length() - pos_s);
+        impl->app_name = cv::String(argv[0]).substr(pos_s + 1, cv::String(argv[0]).length() - pos_s);
     }
 
     impl->error = false;
     impl->error_message = "";
 
     // parse keys
-    std::vector<std::string> k = impl->split_range_string(keys, '{', '}');
+    std::vector<cv::String> k = impl->split_range_string(keys, '{', '}');
 
     int jj = 0;
     for (size_t i = 0; i < k.size(); i++)
     {
-        std::vector<std::string> l = impl->split_string(k[i], '|', true);
+        std::vector<cv::String> l = impl->split_string(k[i], '|', true);
         CommandLineParserParams p;
         p.keys = impl->split_string(l[0]);
         p.def_value = l[1];
@@ -206,11 +203,11 @@ CommandLineParser::CommandLineParser(int argc, const char* const argv[], const s
     jj = 0;
     for (int i = 1; i < argc; i++)
     {
-        std::string s = std::string(argv[i]);
+        cv::String s = cv::String(argv[i]);
 
-        if (s.find('=') != std::string::npos && s.find('=') < s.length())
+        if (s.find('=') != cv::String::npos && s.find('=') < s.length())
         {
-            std::vector<std::string> k_v = impl->split_string(s, '=', true);
+            std::vector<cv::String> k_v = impl->split_string(s, '=', true);
             for (int h = 0; h < 2; h++)
             {
                 if (k_v[0][0] == '-')
@@ -256,12 +253,12 @@ CommandLineParser& CommandLineParser::operator = (const CommandLineParser& parse
     return *this;
 }
 
-void CommandLineParser::about(const std::string& message)
+void CommandLineParser::about(const cv::String& message)
 {
     impl->about_message = message;
 }
 
-void CommandLineParser::Impl::apply_params(const std::string& key, const std::string& value)
+void CommandLineParser::Impl::apply_params(const cv::String& key, const cv::String& value)
 {
     for (size_t i = 0; i < data.size(); i++)
     {
@@ -276,7 +273,7 @@ void CommandLineParser::Impl::apply_params(const std::string& key, const std::st
     }
 }
 
-void CommandLineParser::Impl::apply_params(int i, std::string value)
+void CommandLineParser::Impl::apply_params(int i, cv::String value)
 {
     for (size_t j = 0; j < data.size(); j++)
     {
@@ -292,34 +289,34 @@ void CommandLineParser::Impl::sort_params()
 {
     for (size_t i = 0; i < data.size(); i++)
     {
-        sort(data[i].keys.begin(), data[i].keys.end());
+        std::sort(data[i].keys.begin(), data[i].keys.end());
     }
 
     std::sort (data.begin(), data.end(), cmp_params);
 }
 
-std::string CommandLineParser::Impl::cat_string(const std::string& str) const
+cv::String CommandLineParser::Impl::cat_string(const cv::String& str) const
 {
     int left = 0, right = (int)str.length();
     while( left <= right && str[left] == ' ' )
         left++;
     while( right > left && str[right-1] == ' ' )
         right--;
-    return left >= right ? std::string("") : str.substr(left, right-left);
+    return left >= right ? cv::String("") : str.substr(left, right-left);
 }
 
-std::string CommandLineParser::getPathToApplication() const
+cv::String CommandLineParser::getPathToApplication() const
 {
     return impl->path_to_app;
 }
 
-bool CommandLineParser::has(const std::string& name) const
+bool CommandLineParser::has(const cv::String& name) const
 {
     for (size_t i = 0; i < impl->data.size(); i++)
     {
         for (size_t j = 0; j < impl->data[i].keys.size(); j++)
         {
-            if (name.compare(impl->data[i].keys[j]) == 0 && std::string("true").compare(impl->data[i].def_value) == 0)
+            if (name.compare(impl->data[i].keys[j]) == 0 && cv::String("true").compare(impl->data[i].def_value) == 0)
             {
                 return true;
             }
@@ -337,86 +334,87 @@ void CommandLineParser::printErrors() const
 {
     if (impl->error)
     {
-        std::cout << std::endl << "ERRORS:" << std::endl << impl->error_message << std::endl;
+        printf("\nERRORS:\n%s\n", impl->error_message.c_str());
+        fflush(stdout);
     }
 }
 
 void CommandLineParser::printMessage() const
 {
     if (impl->about_message != "")
-        std::cout << impl->about_message << std::endl;
+        printf("%s\n", impl->about_message.c_str());
 
-    std::cout << "Usage: " << impl->app_name << " [params] ";
+    printf("Usage: %s [params] ", impl->app_name.c_str());
 
     for (size_t i = 0; i < impl->data.size(); i++)
     {
         if (impl->data[i].number > -1)
         {
-            std::string name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1);
+            cv::String name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1);
-            std::cout << name << " ";
+            printf("%s ", name.c_str());
         }
     }
 
-    std::cout << std::endl << std::endl;
+    printf("\n\n");
 
     for (size_t i = 0; i < impl->data.size(); i++)
     {
         if (impl->data[i].number == -1)
         {
-            std::cout << "\t";
+            printf("\t");
             for (size_t j = 0; j < impl->data[i].keys.size(); j++)
             {
-                std::string k = impl->data[i].keys[j];
+                cv::String k = impl->data[i].keys[j];
                 if (k.length() > 1)
                 {
-                    std::cout << "--";
+                    printf("--");
                 }
                 else
                 {
-                    std::cout << "-";
+                    printf("-");
                 }
-                std::cout << k;
+                printf("%s", k.c_str());
 
                 if (j != impl->data[i].keys.size() - 1)
                 {
-                    std::cout << ", ";
+                    printf(", ");
                 }
             }
-            std::string dv = impl->cat_string(impl->data[i].def_value);
+            cv::String dv = impl->cat_string(impl->data[i].def_value);
             if (dv.compare("") != 0)
             {
-                std::cout << " (value:" << dv << ")";
+                printf(" (value:%s)", dv.c_str());
             }
-            std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl;
+            printf("\n\t\t%s\n", impl->data[i].help_message.c_str());
         }
     }
-    std::cout << std::endl;
+    printf("\n");
 
     for (size_t i = 0; i < impl->data.size(); i++)
     {
         if (impl->data[i].number != -1)
         {
-            std::cout << "\t";
+            printf("\t");
-            std::string k = impl->data[i].keys[0];
+            cv::String k = impl->data[i].keys[0];
             k = k.substr(1, k.length() - 1);
 
-            std::cout << k;
+            printf("%s", k.c_str());
 
-            std::string dv = impl->cat_string(impl->data[i].def_value);
+            cv::String dv = impl->cat_string(impl->data[i].def_value);
             if (dv.compare("") != 0)
             {
-                std::cout << " (value:" << dv << ")";
+                printf(" (value:%s)", dv.c_str());
             }
-            std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl;
+            printf("\n\t\t%s\n", impl->data[i].help_message.c_str());
         }
     }
 }
 
-std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::string& _str, char fs, char ss) const
+std::vector<cv::String> CommandLineParser::Impl::split_range_string(const cv::String& _str, char fs, char ss) const
 {
-    std::string str = _str;
+    cv::String str = _str;
-    std::vector<std::string> vec;
+    std::vector<cv::String> vec;
-    std::string word = "";
+    cv::String word = "";
     bool begin = false;
 
     while (!str.empty())
@@ -426,13 +424,13 @@ std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::
             if (begin == true)
             {
                 throw cv::Exception(CV_StsParseError,
-                         std::string("error in split_range_string(")
+                         cv::String("error in split_range_string(")
                          + str
-                         + std::string(", ")
+                         + cv::String(", ")
-                         + std::string(1, fs)
+                         + cv::String(1, fs)
-                         + std::string(", ")
+                         + cv::String(", ")
-                         + std::string(1, ss)
+                         + cv::String(1, ss)
-                         + std::string(")"),
+                         + cv::String(")"),
                          "", __FILE__, __LINE__
                          );
             }
@@ -446,13 +444,13 @@ std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::
             if (begin == false)
             {
                 throw cv::Exception(CV_StsParseError,
-                         std::string("error in split_range_string(")
+                         cv::String("error in split_range_string(")
                          + str
-                         + std::string(", ")
+                         + cv::String(", ")
-                         + std::string(1, fs)
+                         + cv::String(1, fs)
-                         + std::string(", ")
+                         + cv::String(", ")
-                         + std::string(1, ss)
+                         + cv::String(1, ss)
-                         + std::string(")"),
+                         + cv::String(")"),
                          "", __FILE__, __LINE__
                          );
             }
@@ -462,7 +460,7 @@ std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::
 
         if (begin == true)
         {
-            word += str[0];
+            word = word + str[0];
         }
         str = str.substr(1, str.length() - 1);
     }
@@ -470,13 +468,13 @@ std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::
     if (begin == true)
     {
         throw cv::Exception(CV_StsParseError,
-                 std::string("error in split_range_string(")
+                 cv::String("error in split_range_string(")
                  + str
-                 + std::string(", ")
+                 + cv::String(", ")
-                 + std::string(1, fs)
+                 + cv::String(1, fs)
-                 + std::string(", ")
+                 + cv::String(", ")
-                 + std::string(1, ss)
+                 + cv::String(1, ss)
-                 + std::string(")"),
+                 + cv::String(")"),
                  "", __FILE__, __LINE__
                 );
     }
@@ -484,11 +482,11 @@ std::vector<std::string> CommandLineParser::Impl::split_range_string(const std::
     return vec;
 }
 
-std::vector<std::string> CommandLineParser::Impl::split_string(const std::string& _str, char symbol, bool create_empty_item) const
+std::vector<cv::String> CommandLineParser::Impl::split_string(const cv::String& _str, char symbol, bool create_empty_item) const
 {
-    std::string str = _str;
+    cv::String str = _str;
-    std::vector<std::string> vec;
+    std::vector<cv::String> vec;
-    std::string word = "";
+    cv::String word = "";
 
     while (!str.empty())
     {
@@ -502,7 +500,7 @@ std::vector<std::string> CommandLineParser::Impl::split_string(const std::string
         }
         else
         {
-            word += str[0];
+            word = word + str[0];
         }
         str = str.substr(1, str.length() - 1);
     }

modules/core/src/drawing.cpp

@@ -1916,7 +1916,7 @@ static const int* getFontData(int fontFace)
 }
 
 
-void putText( Mat& img, const std::string& text, Point org,
+void putText( Mat& img, const cv::String& text, Point org,
               int fontFace, double fontScale, Scalar color,
               int thickness, int line_type, bool bottomLeftOrigin )
 
@@ -1978,7 +1978,7 @@ void putText( Mat& img, const std::string& text, Point org,
     }
 }
 
-Size getTextSize( const std::string& text, int fontFace, double fontScale, int thickness, int* _base_line)
+Size getTextSize( const cv::String& text, int fontFace, double fontScale, int thickness, int* _base_line)
 {
     Size size;
     double view_x = 0;

modules/core/src/gl_core_3_1.cpp

@@ -15,8 +15,8 @@
                 image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
 
             // prepend a '_' for the Unix C symbol mangling convention
-            std::string symbolName = "_";
+            cv::String symbolName = "_";
-            symbolName += std::string(name);
+            symbolName += cv::String(name);
 
             NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0;
 
@@ -94,9 +94,7 @@
         void* func =  (void*) CV_GL_GET_PROC_ADDRESS(name);
         if (!func)
         {
-            std::ostringstream msg;
+            CV_Error(CV_OpenGlApiCallError, cv::format("Can't load OpenGL extension [%s]", name) );
-            msg << "Can't load OpenGL extension [" << name << "]";
-            CV_Error(CV_OpenGlApiCallError, msg.str());
         }
         return func;
     }

modules/core/src/glob.cpp

@@ -65,7 +65,7 @@ namespace
     {
         DIR* dir = new DIR;
         dir->ent.d_name = 0;
-        dir->handle = ::FindFirstFileA((std::string(path) + "\\*").c_str(), &dir->data);
+        dir->handle = ::FindFirstFileA((cv::String(path) + "\\*").c_str(), &dir->data);
         if(dir->handle == INVALID_HANDLE_VALUE)
         {
             /*closedir will do all cleanup*/
@@ -100,7 +100,7 @@ const char dir_separators[] = "/";
 const char native_separator = '/';
 #endif
 
-static bool isDir(const std::string& path, DIR* dir)
+static bool isDir(const cv::String& path, DIR* dir)
 {
 #if defined WIN32 || defined _WIN32 || defined WINCE
     DWORD attributes;
@@ -168,10 +168,11 @@ static bool wildcmp(const char *string, const char *wild)
     return *wild == 0;
 }
 
-static void glob_rec(const std::string& directory, const std::string& wildchart, std::vector<std::string>& result, bool recursive)
+static void glob_rec(const cv::String& directory, const cv::String& wildchart, std::vector<cv::String>& result, bool recursive)
 {
     DIR *dir;
     struct dirent *ent;
+
     if ((dir = opendir (directory.c_str())) != 0)
     {
         /* find all the files and directories within directory */
@@ -183,7 +184,7 @@ static void glob_rec(const std::string& directory, const std::string& wildchart,
                 if((name[0] == 0) || (name[0] == '.' && name[1] == 0) || (name[0] == '.' && name[1] == '.' && name[2] == 0))
                     continue;
 
-                std::string path = directory + native_separator + name;
+                cv::String path = directory + native_separator + name;
 
                 if (isDir(path, dir))
                 {
@@ -207,14 +208,13 @@ static void glob_rec(const std::string& directory, const std::string& wildchart,
     else CV_Error(CV_StsObjectNotFound, cv::format("could not open directory: %s", directory.c_str()));
 }
 
-void cv::glob(std::string pattern, std::vector<std::string>& result, bool recursive)
+void cv::glob(cv::String pattern, std::vector<cv::String>& result, bool recursive)
 {
     result.clear();
-    std::string path, wildchart;
+    cv::String path, wildchart;
 
     if (isDir(pattern, 0))
     {
-        printf("WE ARE HERE: %s\n", pattern.c_str());
         if(strchr(dir_separators, pattern[pattern.size() - 1]) != 0)
         {
             path = pattern.substr(0, pattern.size() - 1);
@@ -227,7 +227,7 @@ void cv::glob(std::string pattern, std::vector<std::string>& result, bool recurs
     else
     {
         size_t pos = pattern.find_last_of(dir_separators);
-        if (pos == std::string::npos)
+        if (pos == cv::String::npos)
         {
             wildchart = pattern;
             path = ".";

modules/core/src/gpumat.cpp

@@ -172,7 +172,7 @@ namespace
         bool hasEqualOrGreaterBin(int major, int minor) const;
 
     private:
-        static void fromStr(const std::string& set_as_str, std::vector<int>& arr);
+        static void fromStr(const cv::String& set_as_str, std::vector<int>& arr);
 
         std::vector<int> bin;
         std::vector<int> ptx;
@@ -218,9 +218,9 @@ namespace
         return !bin.empty() && (bin.back() >= major * 10 + minor);
     }
 
-    void CudaArch::fromStr(const std::string& set_as_str, std::vector<int>& arr)
+    void CudaArch::fromStr(const cv::String& set_as_str, std::vector<int>& arr)
     {
-        if (set_as_str.find_first_not_of(" ") == std::string::npos)
+        if (set_as_str.find_first_not_of(" ") == cv::String::npos)
             return;
 
         std::istringstream stream(set_as_str);

modules/core/src/persistence.cpp

@@ -116,7 +116,7 @@ static char* icv_itoa( int _val, char* buffer, int /*radix*/ )
     return ptr;
 }
 
-std::string cv::FileStorage::getDefaultObjectName(const std::string& _filename)
+cv::String cv::FileStorage::getDefaultObjectName(const cv::String& _filename)
 {
     static const char* stubname = "unnamed";
     const char* filename = _filename.c_str();
@@ -152,7 +152,7 @@ std::string cv::FileStorage::getDefaultObjectName(const std::string& _filename)
     name = name_buf;
     if( strcmp( name, "_" ) == 0 )
         strcpy( name, stubname );
-    return std::string(name);
+    return cv::String(name);
 }
 
 typedef struct CvGenericHash
@@ -516,7 +516,7 @@ icvFSFlush( CvFileStorage* fs )
 
 
 static void
-icvClose( CvFileStorage* fs, std::string* out )
+icvClose( CvFileStorage* fs, cv::String* out )
 {
     if( out )
         out->clear();
@@ -543,8 +543,7 @@ icvClose( CvFileStorage* fs, std::string* out )
 
     if( fs->outbuf && out )
     {
-        out->resize(fs->outbuf->size());
+        *out = cv::String(fs->outbuf->begin(), fs->outbuf->end());
-        std::copy(fs->outbuf->begin(), fs->outbuf->end(), out->begin());
     }
 }
 
@@ -5011,7 +5010,7 @@ cvSave( const char* filename, const void* struct_ptr,
     if( !fs )
         CV_Error( CV_StsError, "Could not open the file storage. Check the path and permissions" );
 
-    std::string name = _name ? std::string(_name) : cv::FileStorage::getDefaultObjectName(filename);
+    cv::String name = _name ? cv::String(_name) : cv::FileStorage::getDefaultObjectName(filename);
 
     if( comment )
         cvWriteComment( fs, comment, 0 );
@@ -5105,7 +5104,7 @@ stop_search:
 namespace cv
 {
 
-static void getElemSize( const std::string& fmt, size_t& elemSize, size_t& cn )
+static void getElemSize( const cv::String& fmt, size_t& elemSize, size_t& cn )
 {
     const char* dt = fmt.c_str();
     cn = 1;
@@ -5125,7 +5124,7 @@ FileStorage::FileStorage()
     state = UNDEFINED;
 }
 
-FileStorage::FileStorage(const std::string& filename, int flags, const std::string& encoding)
+FileStorage::FileStorage(const cv::String& filename, int flags, const cv::String& encoding)
 {
     state = UNDEFINED;
     open( filename, flags, encoding );
@@ -5146,7 +5145,7 @@ FileStorage::~FileStorage()
     }
 }
 
-bool FileStorage::open(const std::string& filename, int flags, const std::string& encoding)
+bool FileStorage::open(const cv::String& filename, int flags, const cv::String& encoding)
 {
     release();
     fs = Ptr<CvFileStorage>(cvOpenFileStorage( filename.c_str(), 0, flags,
@@ -5168,10 +5167,9 @@ void FileStorage::release()
     state = UNDEFINED;
 }
 
-std::string FileStorage::releaseAndGetString()
+cv::String FileStorage::releaseAndGetString()
 {
-    std::string buf;
+    cv::String buf;
-    buf.reserve(16); // HACK: Work around for compiler bug
     if( fs.obj && fs.obj->outbuf )
         icvClose(fs.obj, &buf);
 
@@ -5184,7 +5182,7 @@ FileNode FileStorage::root(int streamidx) const
     return isOpened() ? FileNode(fs, cvGetRootFileNode(fs, streamidx)) : FileNode();
 }
 
-FileStorage& operator << (FileStorage& fs, const std::string& str)
+FileStorage& operator << (FileStorage& fs, const cv::String& str)
 {
     enum { NAME_EXPECTED = FileStorage::NAME_EXPECTED,
         VALUE_EXPECTED = FileStorage::VALUE_EXPECTED,
@@ -5203,7 +5201,7 @@ FileStorage& operator << (FileStorage& fs, const std::string& str)
         fs.state = fs.structs.empty() || fs.structs.back() == '{' ?
             INSIDE_MAP + NAME_EXPECTED : VALUE_EXPECTED;
         cvEndWriteStruct( *fs );
-        fs.elname = std::string();
+        fs.elname = cv::String();
     }
     else if( fs.state == NAME_EXPECTED + INSIDE_MAP )
     {
@@ -5227,12 +5225,12 @@ FileStorage& operator << (FileStorage& fs, const std::string& str)
             }
             cvStartWriteStruct( *fs, fs.elname.size() > 0 ? fs.elname.c_str() : 0,
                 flags, *_str ? _str : 0 );
-            fs.elname = std::string();
+            fs.elname = cv::String();
         }
         else
         {
             write( fs, fs.elname, (_str[0] == '\\' && (_str[1] == '{' || _str[1] == '}' ||
-                _str[1] == '[' || _str[1] == ']')) ? std::string(_str+1) : str );
+                _str[1] == '[' || _str[1] == ']')) ? cv::String(_str+1) : str );
             if( fs.state == INSIDE_MAP + VALUE_EXPECTED )
                 fs.state = INSIDE_MAP + NAME_EXPECTED;
         }
@@ -5243,7 +5241,7 @@ FileStorage& operator << (FileStorage& fs, const std::string& str)
 }
 
 
-void FileStorage::writeRaw( const std::string& fmt, const uchar* vec, size_t len )
+void FileStorage::writeRaw( const cv::String& fmt, const uchar* vec, size_t len )
 {
     if( !isOpened() )
         return;
@@ -5254,7 +5252,7 @@ void FileStorage::writeRaw( const std::string& fmt, const uchar* vec, size_t len
 }
 
 
-void FileStorage::writeObj( const std::string& name, const void* obj )
+void FileStorage::writeObj( const cv::String& name, const void* obj )
 {
     if( !isOpened() )
         return;
@@ -5262,7 +5260,7 @@ void FileStorage::writeObj( const std::string& name, const void* obj )
 }
 
 
-FileNode FileStorage::operator[](const std::string& nodename) const
+FileNode FileStorage::operator[](const cv::String& nodename) const
 {
     return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename.c_str()));
 }
@@ -5272,7 +5270,7 @@ FileNode FileStorage::operator[](const char* nodename) const
     return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename));
 }
 
-FileNode FileNode::operator[](const std::string& nodename) const
+FileNode FileNode::operator[](const cv::String& nodename) const
 {
     return FileNode(fs, cvGetFileNodeByName(fs, node, nodename.c_str()));
 }
@@ -5288,10 +5286,10 @@ FileNode FileNode::operator[](int i) const
         i == 0 ? *this : FileNode();
 }
 
-std::string FileNode::name() const
+cv::String FileNode::name() const
 {
     const char* str;
-    return !node || (str = cvGetFileNodeName(node)) == 0 ? std::string() : std::string(str);
+    return !node || (str = cvGetFileNodeName(node)) == 0 ? cv::String() : cv::String(str);
 }
 
 void* FileNode::readObj() const
@@ -5406,7 +5404,7 @@ FileNodeIterator& FileNodeIterator::operator -= (int ofs)
 }
 
 
-FileNodeIterator& FileNodeIterator::readRaw( const std::string& fmt, uchar* vec, size_t maxCount )
+FileNodeIterator& FileNodeIterator::readRaw( const cv::String& fmt, uchar* vec, size_t maxCount )
 {
     if( fs && container && remaining > 0 )
     {
@@ -5430,16 +5428,16 @@ FileNodeIterator& FileNodeIterator::readRaw( const std::string& fmt, uchar* vec,
 }
 
 
-void write( FileStorage& fs, const std::string& name, int value )
+void write( FileStorage& fs, const cv::String& name, int value )
 { cvWriteInt( *fs, name.size() ? name.c_str() : 0, value ); }
 
-void write( FileStorage& fs, const std::string& name, float value )
+void write( FileStorage& fs, const cv::String& name, float value )
 { cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); }
 
-void write( FileStorage& fs, const std::string& name, double value )
+void write( FileStorage& fs, const cv::String& name, double value )
 { cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); }
 
-void write( FileStorage& fs, const std::string& name, const std::string& value )
+void write( FileStorage& fs, const cv::String& name, const cv::String& value )
 { cvWriteString( *fs, name.size() ? name.c_str() : 0, value.c_str() ); }
 
 void writeScalar(FileStorage& fs, int value )
@@ -5451,11 +5449,11 @@ void writeScalar(FileStorage& fs, float value )
 void writeScalar(FileStorage& fs, double value )
 { cvWriteReal( *fs, 0, value ); }
 
-void writeScalar(FileStorage& fs, const std::string& value )
+void writeScalar(FileStorage& fs, const cv::String& value )
 { cvWriteString( *fs, 0, value.c_str() ); }
 
 
-void write( FileStorage& fs, const std::string& name, const Mat& value )
+void write( FileStorage& fs, const cv::String& name, const Mat& value )
 {
     if( value.dims <= 2 )
     {
@@ -5470,15 +5468,15 @@ void write( FileStorage& fs, const std::string& name, const Mat& value )
 }
 
 // TODO: the 4 functions below need to be implemented more efficiently
-void write( FileStorage& fs, const std::string& name, const SparseMat& value )
+void write( FileStorage& fs, const cv::String& name, const SparseMat& value )
 {
     Ptr<CvSparseMat> mat = (CvSparseMat*)value;
     cvWrite( *fs, name.size() ? name.c_str() : 0, mat );
 }
 
 
-WriteStructContext::WriteStructContext(FileStorage& _fs, const std::string& name,
+WriteStructContext::WriteStructContext(FileStorage& _fs, const cv::String& name,
-                   int flags, const std::string& typeName) : fs(&_fs)
+                   int flags, const cv::String& typeName) : fs(&_fs)
 {
     cvStartWriteStruct(**fs, !name.empty() ? name.c_str() : 0, flags,
                        !typeName.empty() ? typeName.c_str() : 0);

modules/core/src/system.cpp

@@ -113,7 +113,7 @@ namespace cv
 
 Exception::Exception() { code = 0; line = 0; }
 
-Exception::Exception(int _code, const std::string& _err, const std::string& _func, const std::string& _file, int _line)
+Exception::Exception(int _code, const cv::String& _err, const cv::String& _func, const cv::String& _file, int _line)
 : code(_code), err(_err), func(_func), file(_file), line(_line)
 {
     formatMessage();
@@ -340,27 +340,27 @@ int64 getCPUTickCount(void)
 
 #endif
 
-const std::string& getBuildInformation()
+const cv::String& getBuildInformation()
 {
-    static std::string build_info =
+    static cv::String build_info =
 #include "version_string.inc"
     ;
     return build_info;
 }
 
-std::string format( const char* fmt, ... )
+cv::String format( const char* fmt, ... )
 {
     char buf[1 << 16];
     va_list args;
     va_start( args, fmt );
     vsprintf( buf, fmt, args );
-    return std::string(buf);
+    return cv::String(buf);
 }
 
-std::string tempfile( const char* suffix )
+cv::String tempfile( const char* suffix )
 {
     const char *temp_dir = getenv("OPENCV_TEMP_PATH");
-    std::string fname;
+    cv::String fname;
 
 #if defined WIN32 || defined _WIN32
     char temp_dir2[MAX_PATH + 1] = { 0 };
@@ -372,7 +372,7 @@ std::string tempfile( const char* suffix )
         temp_dir = temp_dir2;
     }
     if(0 == ::GetTempFileNameA(temp_dir, "ocv", 0, temp_file))
-        return std::string();
+        return cv::String();
 
     DeleteFileA(temp_file);
 
@@ -392,12 +392,12 @@ std::string tempfile( const char* suffix )
         fname = temp_dir;
         char ech = fname[fname.size() - 1];
         if(ech != '/' && ech != '\\')
-            fname += "/";
+            fname = fname + "/";
-        fname += "__opencv_temp.XXXXXX";
+        fname = fname + "__opencv_temp.XXXXXX";
     }
 
     const int fd = mkstemp((char*)fname.c_str());
-    if (fd == -1) return std::string();
+    if (fd == -1) return cv::String();
 
     close(fd);
     remove(fname.c_str());

modules/core/test/test_io.cpp

@@ -191,7 +191,7 @@ protected:
 
             int real_int = (int)fs["test_int"];
             double real_real = (double)fs["test_real"];
-            string real_string = (string)fs["test_string"];
+            String real_string = (String)fs["test_string"];
 
             if( real_int != test_int ||
                fabs(real_real - test_real) > DBL_EPSILON*(fabs(test_real)+1) ||
@@ -292,7 +292,7 @@ protected:
                (int)tl[1] != 2 ||
                fabs((double)tl[2] - CV_PI) >= DBL_EPSILON ||
                (int)tl[3] != -3435345 ||
-               (string)tl[4] != "2-502 2-029 3egegeg" ||
+               (String)tl[4] != "2-502 2-029 3egegeg" ||
                tl[5].type() != FileNode::MAP || tl[5].size() != 3 ||
                (int)tl[5]["month"] != 12 ||
                (int)tl[5]["day"] != 31 ||
@@ -459,7 +459,7 @@ TEST(Core_globbing, accurasy)
     std::string patternLena    = cvtest::TS::ptr()->get_data_path() + "lena*.*";
     std::string patternLenaPng = cvtest::TS::ptr()->get_data_path() + "lena.png";
 
-    std::vector<std::string> lenas, pngLenas;
+    std::vector<cv::String> lenas, pngLenas;
     cv::glob(patternLena, lenas, true);
     cv::glob(patternLenaPng, pngLenas, true);
 

modules/features2d/include/opencv2/features2d.hpp

@@ -109,7 +109,7 @@ public:
 };
 
 //! writes vector of keypoints to the file storage
-CV_EXPORTS void write(FileStorage& fs, const std::string& name, const std::vector<KeyPoint>& keypoints);
+CV_EXPORTS void write(FileStorage& fs, const cv::String& name, const std::vector<KeyPoint>& keypoints);
 //! reads vector of keypoints from the specified file storage node
 CV_EXPORTS void read(const FileNode& node, CV_OUT std::vector<KeyPoint>& keypoints);
 
@@ -179,7 +179,7 @@ public:
     CV_WRAP virtual bool empty() const;
 
     // Create feature detector by detector name.
-    CV_WRAP static Ptr<FeatureDetector> create( const std::string& detectorType );
+    CV_WRAP static Ptr<FeatureDetector> create( const cv::String& detectorType );
 
 protected:
     virtual void detectImpl( const Mat& image, std::vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const = 0;
@@ -229,7 +229,7 @@ public:
 
     CV_WRAP virtual bool empty() const;
 
-    CV_WRAP static Ptr<DescriptorExtractor> create( const std::string& descriptorExtractorType );
+    CV_WRAP static Ptr<DescriptorExtractor> create( const cv::String& descriptorExtractorType );
 
 protected:
     virtual void computeImpl( const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors ) const = 0;
@@ -264,7 +264,7 @@ public:
                                      bool useProvidedKeypoints=false ) const = 0;
 
     // Create feature detector and descriptor extractor by name.
-    CV_WRAP static Ptr<Feature2D> create( const std::string& name );
+    CV_WRAP static Ptr<Feature2D> create( const cv::String& name );
 };
 
 /*!
@@ -765,7 +765,7 @@ public:
 
     virtual Ptr<AdjusterAdapter> clone() const = 0;
 
-    static Ptr<AdjusterAdapter> create( const std::string& detectorType );
+    static Ptr<AdjusterAdapter> create( const cv::String& detectorType );
 };
 /** \brief an adaptively adjusting detector that iteratively detects until the desired number
  * of features are detected.
@@ -1141,7 +1141,7 @@ public:
     // but with empty train data.
     virtual Ptr<DescriptorMatcher> clone( bool emptyTrainData=false ) const = 0;
 
-    CV_WRAP static Ptr<DescriptorMatcher> create( const std::string& descriptorMatcherType );
+    CV_WRAP static Ptr<DescriptorMatcher> create( const cv::String& descriptorMatcherType );
 protected:
     /*
      * Class to work with descriptors from several images as with one merged matrix.
@@ -1367,8 +1367,8 @@ public:
     // but with empty train data.
     virtual Ptr<GenericDescriptorMatcher> clone( bool emptyTrainData=false ) const = 0;
 
-    static Ptr<GenericDescriptorMatcher> create( const std::string& genericDescritptorMatcherType,
+    static Ptr<GenericDescriptorMatcher> create( const cv::String& genericDescritptorMatcherType,
-                                                 const std::string &paramsFilename=std::string() );
+                                                 const cv::String &paramsFilename=cv::String() );
 
 protected:
     // In fact the matching is implemented only by the following two methods. These methods suppose

modules/features2d/src/descriptors.cpp

@@ -92,12 +92,12 @@ void DescriptorExtractor::removeBorderKeypoints( std::vector<KeyPoint>& keypoint
     KeyPointsFilter::runByImageBorder( keypoints, imageSize, borderSize );
 }
 
-Ptr<DescriptorExtractor> DescriptorExtractor::create(const std::string& descriptorExtractorType)
+Ptr<DescriptorExtractor> DescriptorExtractor::create(const cv::String& descriptorExtractorType)
 {
     if( descriptorExtractorType.find("Opponent") == 0 )
     {
-        size_t pos = std::string("Opponent").size();
+        size_t pos = cv::String("Opponent").size();
-        std::string type = descriptorExtractorType.substr(pos);
+        cv::String type = descriptorExtractorType.substr(pos);
         return new OpponentColorDescriptorExtractor(DescriptorExtractor::create(type));
     }
 

modules/features2d/src/detectors.cpp

@@ -86,7 +86,7 @@ void FeatureDetector::removeInvalidPoints( const Mat& mask, std::vector<KeyPoint
     KeyPointsFilter::runByPixelsMask( keypoints, mask );
 }
 
-Ptr<FeatureDetector> FeatureDetector::create( const std::string& detectorType )
+Ptr<FeatureDetector> FeatureDetector::create( const cv::String& detectorType )
 {
     if( detectorType.find("Grid") == 0 )
     {

modules/features2d/src/dynamic.cpp

@@ -199,7 +199,7 @@ Ptr<AdjusterAdapter> SurfAdjuster::clone() const
     return cloned_obj;
 }
 
-Ptr<AdjusterAdapter> AdjusterAdapter::create( const std::string& detectorType )
+Ptr<AdjusterAdapter> AdjusterAdapter::create( const cv::String& detectorType )
 {
     Ptr<AdjusterAdapter> adapter;
 

modules/features2d/src/features2d_init.cpp

@@ -44,7 +44,7 @@
 
 using namespace cv;
 
-Ptr<Feature2D> Feature2D::create( const std::string& feature2DType )
+Ptr<Feature2D> Feature2D::create( const cv::String& feature2DType )
 {
     return Algorithm::create<Feature2D>("Feature2D." + feature2DType);
 }

modules/features2d/src/keypoint.cpp

@@ -58,7 +58,7 @@ size_t KeyPoint::hash() const
     return _Val;
 }
 
-void write(FileStorage& fs, const std::string& objname, const std::vector<KeyPoint>& keypoints)
+void write(FileStorage& fs, const cv::String& objname, const std::vector<KeyPoint>& keypoints)
 {
     WriteStructContext ws(fs, objname, CV_NODE_SEQ + CV_NODE_FLOW);
 

modules/features2d/src/matchers.cpp

@@ -456,7 +456,7 @@ void BFMatcher::radiusMatchImpl( const Mat& queryDescriptors, std::vector<std::v
 /*
  * Factory function for DescriptorMatcher creating
  */
-Ptr<DescriptorMatcher> DescriptorMatcher::create( const std::string& descriptorMatcherType )
+Ptr<DescriptorMatcher> DescriptorMatcher::create( const cv::String& descriptorMatcherType )
 {
     DescriptorMatcher* dm = 0;
     if( !descriptorMatcherType.compare( "FlannBased" ) )
@@ -540,7 +540,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
      for(int i = 0; i < (int)ip.size(); ++i)
      {
         CV_Assert(ip[i].type() == FileNode::MAP);
-        std::string _name =  (std::string)ip[i]["name"];
+        cv::String _name =  (cv::String)ip[i]["name"];
         int type =  (int)ip[i]["type"];
 
         switch(type)
@@ -559,7 +559,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
             indexParams->setDouble(_name, (double) ip[i]["value"]);
             break;
         case CV_USRTYPE1:
-            indexParams->setString(_name, (std::string) ip[i]["value"]);
+            indexParams->setString(_name, (cv::String) ip[i]["value"]);
             break;
         case CV_MAKETYPE(CV_USRTYPE1,2):
             indexParams->setBool(_name, (int) ip[i]["value"] != 0);
@@ -579,7 +579,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
      for(int i = 0; i < (int)sp.size(); ++i)
      {
         CV_Assert(sp[i].type() == FileNode::MAP);
-        std::string _name =  (std::string)sp[i]["name"];
+        cv::String _name =  (cv::String)sp[i]["name"];
         int type =  (int)sp[i]["type"];
 
         switch(type)
@@ -598,7 +598,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
             searchParams->setDouble(_name, (double) ip[i]["value"]);
             break;
         case CV_USRTYPE1:
-            searchParams->setString(_name, (std::string) ip[i]["value"]);
+            searchParams->setString(_name, (cv::String) ip[i]["value"]);
             break;
         case CV_MAKETYPE(CV_USRTYPE1,2):
             searchParams->setBool(_name, (int) ip[i]["value"] != 0);
@@ -618,9 +618,9 @@ void FlannBasedMatcher::write( FileStorage& fs) const
 
      if (indexParams)
      {
-         std::vector<std::string> names;
+         std::vector<cv::String> names;
          std::vector<int> types;
-         std::vector<std::string> strValues;
+         std::vector<cv::String> strValues;
          std::vector<double> numValues;
 
          indexParams->getAll(names, types, strValues, numValues);
@@ -669,9 +669,9 @@ void FlannBasedMatcher::write( FileStorage& fs) const
 
      if (searchParams)
      {
-         std::vector<std::string> names;
+         std::vector<cv::String> names;
          std::vector<int> types;
-         std::vector<std::string> strValues;
+         std::vector<cv::String> strValues;
          std::vector<double> numValues;
 
          searchParams->getAll(names, types, strValues, numValues);
@@ -1060,8 +1060,8 @@ bool GenericDescriptorMatcher::empty() const
 /*
  * Factory function for GenericDescriptorMatch creating
  */
-Ptr<GenericDescriptorMatcher> GenericDescriptorMatcher::create( const std::string& genericDescritptorMatcherType,
+Ptr<GenericDescriptorMatcher> GenericDescriptorMatcher::create( const cv::String& genericDescritptorMatcherType,
-                                                                const std::string &paramsFilename )
+                                                                const cv::String &paramsFilename )
 {
     Ptr<GenericDescriptorMatcher> descriptorMatcher =
         Algorithm::create<GenericDescriptorMatcher>("DescriptorMatcher." + genericDescritptorMatcherType);

modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst

@@ -138,7 +138,7 @@ The method constructs a fast search structure from a set of features using the s
 
             struct SavedIndexParams : public IndexParams
             {
-                SavedIndexParams( std::string filename );
+                SavedIndexParams( cv::String filename );
             };
 
 
@@ -199,7 +199,7 @@ flann::Index_<T>::save
 ------------------------------
 Saves the index to a file.
 
-.. ocv:function:: void flann::Index_<T>::save(std::string filename)
+.. ocv:function:: void flann::Index_<T>::save(cv::String filename)
 
     :param filename: The file to save the index to
 

modules/flann/include/opencv2/flann.hpp

@@ -112,7 +112,7 @@ public:
         int radiusSearch(const Mat& query, Mat& indices, Mat& dists,
                          DistanceType radius, const ::cvflann::SearchParams& params);
 
-        void save(std::string filename) { nnIndex->save(filename); }
+        void save(cv::String filename) { nnIndex->save(filename); }
 
         int veclen() const { return nnIndex->veclen(); }
 
@@ -244,7 +244,7 @@ public:
     int radiusSearch(const std::vector<ElementType>& query, std::vector<int>& indices, std::vector<DistanceType>& dists, DistanceType radius, const ::cvflann::SearchParams& params);
     int radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& params);
 
-    void save(std::string filename)
+    void save(cv::String filename)
         {
             if (nnIndex_L1) nnIndex_L1->save(filename);
             if (nnIndex_L2) nnIndex_L2->save(filename);

modules/flann/include/opencv2/flann/any.h

@@ -106,6 +106,11 @@ template<> inline void big_any_policy<flann_algorithm_t>::print(std::ostream& ou
     out << int(*reinterpret_cast<flann_algorithm_t const*>(*src));
 }
 
+template<> inline void big_any_policy<cv::String>::print(std::ostream& out, void* const* src)
+{
+    out << (*reinterpret_cast<cv::String const*>(*src)).c_str();
+}
+
 template<typename T>
 struct choose_policy
 {

modules/flann/include/opencv2/flann/flann_base.hpp

@@ -62,7 +62,7 @@ inline void log_verbosity(int level)
  */
 struct SavedIndexParams : public IndexParams
 {
-    SavedIndexParams(std::string filename)
+    SavedIndexParams(cv::String filename)
     {
         (* this)["algorithm"] = FLANN_INDEX_SAVED;
         (*this)["filename"] = filename;
@@ -71,7 +71,7 @@ struct SavedIndexParams : public IndexParams
 
 
 template<typename Distance>
-NNIndex<Distance>* load_saved_index(const Matrix<typename Distance::ElementType>& dataset, const std::string& filename, Distance distance)
+NNIndex<Distance>* load_saved_index(const Matrix<typename Distance::ElementType>& dataset, const cv::String& filename, Distance distance)
 {
     typedef typename Distance::ElementType ElementType;
 
@@ -111,7 +111,7 @@ public:
         loaded_ = false;
 
         if (index_type == FLANN_INDEX_SAVED) {
-            nnIndex_ = load_saved_index<Distance>(features, get_param<std::string>(params,"filename"), distance);
+            nnIndex_ = load_saved_index<Distance>(features, get_param<cv::String>(params,"filename"), distance);
             loaded_ = true;
         }
         else {
@@ -134,7 +134,7 @@ public:
         }
     }
 
-    void save(std::string filename)
+    void save(cv::String filename)
     {
         FILE* fout = fopen(filename.c_str(), "wb");
         if (fout == NULL) {

modules/flann/include/opencv2/flann/general.h

@@ -31,19 +31,17 @@
 #ifndef OPENCV_FLANN_GENERAL_H_
 #define OPENCV_FLANN_GENERAL_H_
 
-#include "defines.h"
+#include "opencv2/core.hpp"
-#include <stdexcept>
-#include <cassert>
 
 namespace cvflann
 {
 
-class FLANNException : public std::runtime_error
+class FLANNException : public cv::Exception
 {
 public:
-    FLANNException(const char* message) : std::runtime_error(message) { }
+    FLANNException(const char* message) : cv::Exception(0, message, "", __FILE__, __LINE__) { }
 
-    FLANNException(const std::string& message) : std::runtime_error(message) { }
+    FLANNException(const cv::String& message) : cv::Exception(0, message, "", __FILE__, __LINE__) { }
 };
 
 }

modules/flann/include/opencv2/flann/hdf5.h

@@ -73,7 +73,7 @@ hid_t get_hdf5_type<double>() { return H5T_NATIVE_DOUBLE; }
 #define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y));
 
 template<typename T>
-void save_to_file(const cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+void save_to_file(const cvflann::Matrix<T>& dataset, const cv::String& filename, const cv::String& name)
 {
 
 #if H5Eset_auto_vers == 2
@@ -125,7 +125,7 @@ void save_to_file(const cvflann::Matrix<T>& dataset, const std::string& filename
 
 
 template<typename T>
-void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+void load_from_file(cvflann::Matrix<T>& dataset, const cv::String& filename, const cv::String& name)
 {
     herr_t status;
     hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
@@ -166,7 +166,7 @@ namespace mpi
  * @param name Name of dataset inside file
  */
 template<typename T>
-void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+void load_from_file(cvflann::Matrix<T>& dataset, const cv::String& filename, const cv::String& name)
 {
     MPI_Comm comm  = MPI_COMM_WORLD;
     MPI_Info info  = MPI_INFO_NULL;

modules/flann/include/opencv2/flann/lsh_table.h

@@ -266,9 +266,7 @@ private:
         const size_t key_size_upper_bound = std::min(sizeof(BucketKey) * CHAR_BIT + 1, sizeof(size_t) * CHAR_BIT);
         if (key_size < key_size_lower_bound || key_size >= key_size_upper_bound)
         {
-            std::stringstream errorMessage;
+            CV_Error(CV_StsBadArg, cv::format("Invalid key_size (=%d). Valid values for your system are %d <= key_size < %d.", (int)key_size, (int)key_size_lower_bound, (int)key_size_upper_bound));
-            errorMessage << "Invalid key_size (=" << key_size << "). Valid values for your system are " << key_size_lower_bound << " <= key_size < " << key_size_upper_bound << ".";
-            CV_Error(CV_StsBadArg, errorMessage.str());
         }
 
         speed_level_ = kHash;

modules/flann/include/opencv2/flann/miniflann.hpp

@@ -59,20 +59,20 @@ struct CV_EXPORTS IndexParams
     IndexParams();
     ~IndexParams();
 
-    std::string getString(const std::string& key, const std::string& defaultVal=std::string()) const;
+    cv::String getString(const cv::String& key, const cv::String& defaultVal=cv::String()) const;
-    int getInt(const std::string& key, int defaultVal=-1) const;
+    int getInt(const cv::String& key, int defaultVal=-1) const;
-    double getDouble(const std::string& key, double defaultVal=-1) const;
+    double getDouble(const cv::String& key, double defaultVal=-1) const;
 
-    void setString(const std::string& key, const std::string& value);
+    void setString(const cv::String& key, const cv::String& value);
-    void setInt(const std::string& key, int value);
+    void setInt(const cv::String& key, int value);
-    void setDouble(const std::string& key, double value);
+    void setDouble(const cv::String& key, double value);
-    void setFloat(const std::string& key, float value);
+    void setFloat(const cv::String& key, float value);
-    void setBool(const std::string& key, bool value);
+    void setBool(const cv::String& key, bool value);
     void setAlgorithm(int value);
 
-    void getAll(std::vector<std::string>& names,
+    void getAll(std::vector<cv::String>& names,
                 std::vector<int>& types,
-                std::vector<std::string>& strValues,
+                std::vector<cv::String>& strValues,
                 std::vector<double>& numValues) const;
 
     void* params;
@@ -119,7 +119,7 @@ struct CV_EXPORTS LshIndexParams : public IndexParams
 
 struct CV_EXPORTS SavedIndexParams : public IndexParams
 {
-    SavedIndexParams(const std::string& filename);
+    SavedIndexParams(const cv::String& filename);
 };
 
 struct CV_EXPORTS SearchParams : public IndexParams
@@ -142,8 +142,8 @@ public:
                              OutputArray dists, double radius, int maxResults,
                              const SearchParams& params=SearchParams());
 
-    CV_WRAP virtual void save(const std::string& filename) const;
+    CV_WRAP virtual void save(const cv::String& filename) const;
-    CV_WRAP virtual bool load(InputArray features, const std::string& filename);
+    CV_WRAP virtual bool load(InputArray features, const cv::String& filename);
     CV_WRAP virtual void release();
     CV_WRAP cvflann::flann_distance_t getDistance() const;
     CV_WRAP cvflann::flann_algorithm_t getAlgorithm() const;

modules/flann/include/opencv2/flann/params.h

@@ -39,7 +39,7 @@
 namespace cvflann
 {
 
-typedef std::map<std::string, any> IndexParams;
+typedef std::map<cv::String, any> IndexParams;
 
 struct SearchParams : public IndexParams
 {
@@ -56,7 +56,7 @@ struct SearchParams : public IndexParams
 
 
 template<typename T>
-T get_param(const IndexParams& params, std::string name, const T& default_value)
+T get_param(const IndexParams& params, cv::String name, const T& default_value)
 {
     IndexParams::const_iterator it = params.find(name);
     if (it != params.end()) {
@@ -68,14 +68,14 @@ T get_param(const IndexParams& params, std::string name, const T& default_value)
 }
 
 template<typename T>
-T get_param(const IndexParams& params, std::string name)
+T get_param(const IndexParams& params, cv::String name)
 {
     IndexParams::const_iterator it = params.find(name);
     if (it != params.end()) {
         return it->second.cast<T>();
     }
     else {
-        throw FLANNException(std::string("Missing parameter '")+name+std::string("' in the parameters given"));
+        throw FLANNException(cv::String("Missing parameter '")+name+cv::String("' in the parameters given"));
     }
 }
 

modules/flann/src/miniflann.cpp

@@ -26,7 +26,7 @@ IndexParams::IndexParams()
 }
 
 template<typename T>
-T getParam(const IndexParams& _p, const std::string& key, const T& defaultVal=T())
+T getParam(const IndexParams& _p, const cv::String& key, const T& defaultVal=T())
 {
     ::cvflann::IndexParams& p = get_params(_p);
     ::cvflann::IndexParams::const_iterator it = p.find(key);
@@ -36,49 +36,49 @@ T getParam(const IndexParams& _p, const std::string& key, const T& defaultVal=T(
 }
 
 template<typename T>
-void setParam(IndexParams& _p, const std::string& key, const T& value)
+void setParam(IndexParams& _p, const cv::String& key, const T& value)
 {
     ::cvflann::IndexParams& p = get_params(_p);
     p[key] = value;
 }
 
-std::string IndexParams::getString(const std::string& key, const std::string& defaultVal) const
+cv::String IndexParams::getString(const cv::String& key, const cv::String& defaultVal) const
 {
     return getParam(*this, key, defaultVal);
 }
 
-int IndexParams::getInt(const std::string& key, int defaultVal) const
+int IndexParams::getInt(const cv::String& key, int defaultVal) const
 {
     return getParam(*this, key, defaultVal);
 }
 
-double IndexParams::getDouble(const std::string& key, double defaultVal) const
+double IndexParams::getDouble(const cv::String& key, double defaultVal) const
 {
     return getParam(*this, key, defaultVal);
 }
 
 
-void IndexParams::setString(const std::string& key, const std::string& value)
+void IndexParams::setString(const cv::String& key, const cv::String& value)
 {
     setParam(*this, key, value);
 }
 
-void IndexParams::setInt(const std::string& key, int value)
+void IndexParams::setInt(const cv::String& key, int value)
 {
     setParam(*this, key, value);
 }
 
-void IndexParams::setDouble(const std::string& key, double value)
+void IndexParams::setDouble(const cv::String& key, double value)
 {
     setParam(*this, key, value);
 }
 
-void IndexParams::setFloat(const std::string& key, float value)
+void IndexParams::setFloat(const cv::String& key, float value)
 {
     setParam(*this, key, value);
 }
 
-void IndexParams::setBool(const std::string& key, bool value)
+void IndexParams::setBool(const cv::String& key, bool value)
 {
     setParam(*this, key, value);
 }
@@ -88,9 +88,9 @@ void IndexParams::setAlgorithm(int value)
     setParam(*this, "algorithm", (cvflann::flann_algorithm_t)value);
 }
 
-void IndexParams::getAll(std::vector<std::string>& names,
+void IndexParams::getAll(std::vector<cv::String>& names,
             std::vector<int>& types,
-            std::vector<std::string>& strValues,
+            std::vector<cv::String>& strValues,
             std::vector<double>& numValues) const
 {
     names.clear();
@@ -106,7 +106,7 @@ void IndexParams::getAll(std::vector<std::string>& names,
         names.push_back(it->first);
         try
         {
-            std::string val = it->second.cast<std::string>();
+            cv::String val = it->second.cast<cv::String>();
             types.push_back(CV_USRTYPE1);
             strValues.push_back(val);
             numValues.push_back(-1);
@@ -285,9 +285,9 @@ LshIndexParams::LshIndexParams(int table_number, int key_size, int multi_probe_l
     p["multi_probe_level"] = multi_probe_level;
 }
 
-SavedIndexParams::SavedIndexParams(const std::string& _filename)
+SavedIndexParams::SavedIndexParams(const cv::String& _filename)
 {
-    std::string filename = _filename;
+    cv::String filename = _filename;
     ::cvflann::IndexParams& p = get_params(*this);
 
     p["algorithm"] = FLANN_INDEX_SAVED;
@@ -357,7 +357,7 @@ void Index::build(InputArray _data, const IndexParams& params, flann_distance_t
     algo = getParam<flann_algorithm_t>(params, "algorithm", FLANN_INDEX_LINEAR);
     if( algo == FLANN_INDEX_SAVED )
     {
-        load(_data, getParam<std::string>(params, "filename", std::string()));
+        load(_data, getParam<cv::String>(params, "filename", cv::String()));
         return;
     }
 
@@ -654,7 +654,7 @@ template<typename Distance> void saveIndex(const Index* index0, const void* inde
     saveIndex_< ::cvflann::Index<Distance> >(index0, index, fout);
 }
 
-void Index::save(const std::string& filename) const
+void Index::save(const cv::String& filename) const
 {
     FILE* fout = fopen(filename.c_str(), "wb");
     if (fout == NULL)
@@ -720,7 +720,7 @@ bool loadIndex(Index* index0, void*& index, const Mat& data, FILE* fin, const Di
     return loadIndex_<Distance, ::cvflann::Index<Distance> >(index0, index, data, fin, dist);
 }
 
-bool Index::load(InputArray _data, const std::string& filename)
+bool Index::load(InputArray _data, const cv::String& filename)
 {
     Mat data = _data.getMat();
     bool ok = true;

modules/highgui/include/opencv2/highgui.hpp

@@ -67,21 +67,21 @@ enum {
     WND_PROP_OPENGL       = CV_WND_PROP_OPENGL       // opengl support
 };
 
-CV_EXPORTS_W void namedWindow(const std::string& winname, int flags = WINDOW_AUTOSIZE);
+CV_EXPORTS_W void namedWindow(const cv::String& winname, int flags = WINDOW_AUTOSIZE);
-CV_EXPORTS_W void destroyWindow(const std::string& winname);
+CV_EXPORTS_W void destroyWindow(const cv::String& winname);
 CV_EXPORTS_W void destroyAllWindows();
 
 CV_EXPORTS_W int startWindowThread();
 
 CV_EXPORTS_W int waitKey(int delay = 0);
 
-CV_EXPORTS_W void imshow(const std::string& winname, InputArray mat);
+CV_EXPORTS_W void imshow(const cv::String& winname, InputArray mat);
 
-CV_EXPORTS_W void resizeWindow(const std::string& winname, int width, int height);
+CV_EXPORTS_W void resizeWindow(const cv::String& winname, int width, int height);
-CV_EXPORTS_W void moveWindow(const std::string& winname, int x, int y);
+CV_EXPORTS_W void moveWindow(const cv::String& winname, int x, int y);
 
-CV_EXPORTS_W void setWindowProperty(const std::string& winname, int prop_id, double prop_value);//YV
+CV_EXPORTS_W void setWindowProperty(const cv::String& winname, int prop_id, double prop_value);//YV
-CV_EXPORTS_W double getWindowProperty(const std::string& winname, int prop_id);//YV
+CV_EXPORTS_W double getWindowProperty(const cv::String& winname, int prop_id);//YV
 
 enum
 {
@@ -110,45 +110,45 @@ enum
 typedef void (*MouseCallback)(int event, int x, int y, int flags, void* userdata);
 
 //! assigns callback for mouse events
-CV_EXPORTS void setMouseCallback(const std::string& winname, MouseCallback onMouse, void* userdata = 0);
+CV_EXPORTS void setMouseCallback(const cv::String& winname, MouseCallback onMouse, void* userdata = 0);
 
 
 typedef void (CV_CDECL *TrackbarCallback)(int pos, void* userdata);
 
-CV_EXPORTS int createTrackbar(const std::string& trackbarname, const std::string& winname,
+CV_EXPORTS int createTrackbar(const cv::String& trackbarname, const cv::String& winname,
                               int* value, int count,
                               TrackbarCallback onChange = 0,
                               void* userdata = 0);
 
-CV_EXPORTS_W int getTrackbarPos(const std::string& trackbarname, const std::string& winname);
+CV_EXPORTS_W int getTrackbarPos(const cv::String& trackbarname, const cv::String& winname);
-CV_EXPORTS_W void setTrackbarPos(const std::string& trackbarname, const std::string& winname, int pos);
+CV_EXPORTS_W void setTrackbarPos(const cv::String& trackbarname, const cv::String& winname, int pos);
 
 // OpenGL support
 
 typedef void (*OpenGlDrawCallback)(void* userdata);
-CV_EXPORTS void setOpenGlDrawCallback(const std::string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0);
+CV_EXPORTS void setOpenGlDrawCallback(const cv::String& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0);
 
-CV_EXPORTS void setOpenGlContext(const std::string& winname);
+CV_EXPORTS void setOpenGlContext(const cv::String& winname);
 
-CV_EXPORTS void updateWindow(const std::string& winname);
+CV_EXPORTS void updateWindow(const cv::String& winname);
 
 //Only for Qt
 
-CV_EXPORTS CvFont fontQt(const std::string& nameFont, int pointSize=-1,
+CV_EXPORTS CvFont fontQt(const cv::String& nameFont, int pointSize=-1,
                          Scalar color=Scalar::all(0), int weight=CV_FONT_NORMAL,
                          int style=CV_STYLE_NORMAL, int spacing=0);
-CV_EXPORTS void addText( const Mat& img, const std::string& text, Point org, CvFont font);
+CV_EXPORTS void addText( const Mat& img, const cv::String& text, Point org, CvFont font);
 
-CV_EXPORTS void displayOverlay(const std::string& winname, const std::string& text, int delayms CV_DEFAULT(0));
+CV_EXPORTS void displayOverlay(const cv::String& winname, const cv::String& text, int delayms CV_DEFAULT(0));
-CV_EXPORTS void displayStatusBar(const std::string& winname, const std::string& text, int delayms CV_DEFAULT(0));
+CV_EXPORTS void displayStatusBar(const cv::String& winname, const cv::String& text, int delayms CV_DEFAULT(0));
 
-CV_EXPORTS void saveWindowParameters(const std::string& windowName);
+CV_EXPORTS void saveWindowParameters(const cv::String& windowName);
-CV_EXPORTS void loadWindowParameters(const std::string& windowName);
+CV_EXPORTS void loadWindowParameters(const cv::String& windowName);
 CV_EXPORTS  int startLoop(int (*pt2Func)(int argc, char *argv[]), int argc, char* argv[]);
 CV_EXPORTS  void stopLoop();
 
 typedef void (CV_CDECL *ButtonCallback)(int state, void* userdata);
-CV_EXPORTS int createButton( const std::string& bar_name, ButtonCallback on_change,
+CV_EXPORTS int createButton( const cv::String& bar_name, ButtonCallback on_change,
                              void* userdata=NULL, int type=CV_PUSH_BUTTON,
                              bool initial_button_state=0);
 
@@ -182,12 +182,12 @@ enum
     IMWRITE_PXM_BINARY =32
 };
 
-CV_EXPORTS_W Mat imread( const std::string& filename, int flags=1 );
+CV_EXPORTS_W Mat imread( const cv::String& filename, int flags=1 );
-CV_EXPORTS_W bool imwrite( const std::string& filename, InputArray img,
+CV_EXPORTS_W bool imwrite( const cv::String& filename, InputArray img,
               const std::vector<int>& params=std::vector<int>());
 CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
 CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst );
-CV_EXPORTS_W bool imencode( const std::string& ext, InputArray img,
+CV_EXPORTS_W bool imencode( const cv::String& ext, InputArray img,
                             CV_OUT std::vector<uchar>& buf,
                             const std::vector<int>& params=std::vector<int>());
 
@@ -200,11 +200,11 @@ class CV_EXPORTS_W VideoCapture
 {
 public:
     CV_WRAP VideoCapture();
-    CV_WRAP VideoCapture(const std::string& filename);
+    CV_WRAP VideoCapture(const cv::String& filename);
     CV_WRAP VideoCapture(int device);
 
     virtual ~VideoCapture();
-    CV_WRAP virtual bool open(const std::string& filename);
+    CV_WRAP virtual bool open(const cv::String& filename);
     CV_WRAP virtual bool open(int device);
     CV_WRAP virtual bool isOpened() const;
     CV_WRAP virtual void release();
@@ -226,11 +226,11 @@ class CV_EXPORTS_W VideoWriter
 {
 public:
     CV_WRAP VideoWriter();
-    CV_WRAP VideoWriter(const std::string& filename, int fourcc, double fps,
+    CV_WRAP VideoWriter(const cv::String& filename, int fourcc, double fps,
                 Size frameSize, bool isColor=true);
 
     virtual ~VideoWriter();
-    CV_WRAP virtual bool open(const std::string& filename, int fourcc, double fps,
+    CV_WRAP virtual bool open(const cv::String& filename, int fourcc, double fps,
                       Size frameSize, bool isColor=true);
     CV_WRAP virtual bool isOpened() const;
     CV_WRAP virtual void release();

modules/highgui/src/bitstrm.cpp

@@ -110,7 +110,7 @@ void  RBaseStream::readBlock()
 }
 
 
-bool  RBaseStream::open( const std::string& filename )
+bool  RBaseStream::open( const cv::String& filename )
 {
     close();
     allocate();
@@ -388,7 +388,7 @@ void  WBaseStream::writeBlock()
 }
 
 
-bool  WBaseStream::open( const std::string& filename )
+bool  WBaseStream::open( const cv::String& filename )
 {
     close();
     allocate();

modules/highgui/src/bitstrm.hpp

@@ -66,7 +66,7 @@ public:
     RBaseStream();
     virtual ~RBaseStream();
 
-    virtual bool  open( const std::string& filename );
+    virtual bool  open( const cv::String& filename );
     virtual bool  open( const Mat& buf );
     virtual void  close();
     bool          isOpened();
@@ -123,7 +123,7 @@ public:
     WBaseStream();
     virtual ~WBaseStream();
 
-    virtual bool  open( const std::string& filename );
+    virtual bool  open( const cv::String& filename );
     virtual bool  open( std::vector<uchar>& buf );
     virtual void  close();
     bool          isOpened();

modules/highgui/src/cap.cpp

@@ -445,7 +445,7 @@ namespace cv
 VideoCapture::VideoCapture()
 {}
 
-VideoCapture::VideoCapture(const std::string& filename)
+VideoCapture::VideoCapture(const cv::String& filename)
 {
     open(filename);
 }
@@ -460,7 +460,7 @@ VideoCapture::~VideoCapture()
     cap.release();
 }
 
-bool VideoCapture::open(const std::string& filename)
+bool VideoCapture::open(const cv::String& filename)
 {
     if (!isOpened())
     cap = cvCreateFileCapture(filename.c_str());
@@ -532,7 +532,7 @@ double VideoCapture::get(int propId)
 VideoWriter::VideoWriter()
 {}
 
-VideoWriter::VideoWriter(const std::string& filename, int fourcc, double fps, Size frameSize, bool isColor)
+VideoWriter::VideoWriter(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor)
 {
     open(filename, fourcc, fps, frameSize, isColor);
 }
@@ -547,7 +547,7 @@ VideoWriter::~VideoWriter()
     release();
 }
 
-bool VideoWriter::open(const std::string& filename, int fourcc, double fps, Size frameSize, bool isColor)
+bool VideoWriter::open(const cv::String& filename, int fourcc, double fps, Size frameSize, bool isColor)
 {
     writer = cvCreateVideoWriter(filename.c_str(), fourcc, fps, frameSize, isColor);
     return isOpened();

modules/highgui/src/cap_openni.cpp

@@ -66,7 +66,7 @@
 
 #include "XnCppWrapper.h"
 
-const std::string XMLConfig =
+const cv::String XMLConfig =
 "<OpenNI>"
         "<Licenses>"
         "<License vendor=\"PrimeSense\" key=\"0KOIk2JeIBYClPWVnMoRKn5cdY4=\"/>"
@@ -559,7 +559,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to initialize the context: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -569,7 +569,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate production trees: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -587,7 +587,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create production tree: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -596,7 +596,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to run xml script: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -607,7 +607,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate depth generators: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
     if( depthList.IsEmpty() )
@@ -619,7 +619,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create depth generator: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -629,7 +629,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate image generators: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -639,7 +639,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
         if( status != XN_STATUS_OK )
         {
             std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create image generator: "
-                      <<  std::string(xnGetStatusString(status)) << std::endl;
+                      <<  cv::String(xnGetStatusString(status)) << std::endl;
             return;
         }
     }
@@ -667,7 +667,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to start generating OpenNI data: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -698,7 +698,7 @@ CvCapture_OpenNI::CvCapture_OpenNI(const char * filename)
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to initialize the context: "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -707,7 +707,7 @@ CvCapture_OpenNI::CvCapture_OpenNI(const char * filename)
     if( status != XN_STATUS_OK )
     {
         std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to open input file (" << filename << "): "
-                  << std::string(xnGetStatusString(status)) << std::endl;
+                  << cv::String(xnGetStatusString(status)) << std::endl;
         return;
     }
 
@@ -862,7 +862,7 @@ double CvCapture_OpenNI::getCommonProperty( int propIdx )
         break;
     default :
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Such parameter (propIdx=" << propIdx << ") isn't supported for getting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }
@@ -923,7 +923,7 @@ bool CvCapture_OpenNI::setCommonProperty( int propIdx, double propValue )
         break;
     default:
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Such parameter (propIdx=" << propIdx << ") isn't supported for setting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }
@@ -978,7 +978,7 @@ double CvCapture_OpenNI::getDepthGeneratorProperty( int propIdx )
         break;
     default :
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Depth generator does not support such parameter (propIdx=" << propIdx << ") for getting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }
@@ -1032,7 +1032,7 @@ bool CvCapture_OpenNI::setDepthGeneratorProperty( int propIdx, double propValue
         break;
     default:
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Depth generator does not support such parameter (propIdx=" << propIdx << ") for setting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }
@@ -1074,7 +1074,7 @@ double CvCapture_OpenNI::getImageGeneratorProperty( int propIdx )
         break;
     default :
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Image generator does not support such parameter (propIdx=" << propIdx << ") for getting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }
@@ -1135,7 +1135,7 @@ bool CvCapture_OpenNI::setImageGeneratorProperty( int propIdx, double propValue
     }
     default:
     {
-        std::stringstream ss;
+        cv::Stringstream ss;
         ss << "Image generator does not support such parameter (propIdx=" << propIdx << ") for setting.\n";
         CV_Error( CV_StsBadArg, ss.str().c_str() );
     }

modules/highgui/src/cap_pvapi.cpp

@@ -356,7 +356,7 @@ bool CvCaptureCAM_PvAPI::setProperty( int property_id, double value )
         }
         else
         {
-            std::string ip=cv::format("%d.%d.%d.%d", ((int)value>>24)&255, ((int)value>>16)&255, ((int)value>>8)&255, (int)value&255);
+            cv::String ip=cv::format("%d.%d.%d.%d", ((int)value>>24)&255, ((int)value>>16)&255, ((int)value>>8)&255, (int)value&255);
             if ((PvAttrEnumSet(Camera.Handle,"MulticastEnable", "On")==ePvErrSuccess) &&
                 (PvAttrStringSet(Camera.Handle, "MulticastIPAddress", ip.c_str())==ePvErrSuccess))
                 break;

modules/highgui/src/grfmt_base.cpp

@@ -54,7 +54,7 @@ BaseImageDecoder::BaseImageDecoder()
     m_buf_supported = false;
 }
 
-bool BaseImageDecoder::setSource( const std::string& filename )
+bool BaseImageDecoder::setSource( const cv::String& filename )
 {
     m_filename = filename;
     m_buf.release();
@@ -65,7 +65,7 @@ bool BaseImageDecoder::setSource( const Mat& buf )
 {
     if( !m_buf_supported )
         return false;
-    m_filename = std::string();
+    m_filename = cv::String();
     m_buf = buf;
     return true;
 }
@@ -75,7 +75,7 @@ size_t BaseImageDecoder::signatureLength() const
     return m_signature.size();
 }
 
-bool BaseImageDecoder::checkSignature( const std::string& signature ) const
+bool BaseImageDecoder::checkSignature( const cv::String& signature ) const
 {
     size_t len = signatureLength();
     return signature.size() >= len && memcmp( signature.c_str(), m_signature.c_str(), len ) == 0;
@@ -96,12 +96,12 @@ bool  BaseImageEncoder::isFormatSupported( int depth ) const
     return depth == CV_8U;
 }
 
-std::string BaseImageEncoder::getDescription() const
+cv::String BaseImageEncoder::getDescription() const
 {
     return m_description;
 }
 
-bool BaseImageEncoder::setDestination( const std::string& filename )
+bool BaseImageEncoder::setDestination( const cv::String& filename )
 {
     m_filename = filename;
     m_buf = 0;
@@ -114,7 +114,7 @@ bool BaseImageEncoder::setDestination( std::vector<uchar>& buf )
         return false;
     m_buf = &buf;
     m_buf->clear();
-    m_filename = std::string();
+    m_filename = cv::String();
     return true;
 }
 
@@ -127,7 +127,7 @@ void BaseImageEncoder::throwOnEror() const
 {
     if(!m_last_error.empty())
     {
-        std::string msg = "Raw image encoder error: " + m_last_error;
+        cv::String msg = "Raw image encoder error: " + m_last_error;
         CV_Error( CV_BadImageSize, msg.c_str() );
     }
 }

modules/highgui/src/grfmt_base.hpp

@@ -65,21 +65,21 @@ public:
     int height() const { return m_height; };
     virtual int type() const { return m_type; };
 
-    virtual bool setSource( const std::string& filename );
+    virtual bool setSource( const cv::String& filename );
     virtual bool setSource( const Mat& buf );
     virtual bool readHeader() = 0;
     virtual bool readData( Mat& img ) = 0;
 
     virtual size_t signatureLength() const;
-    virtual bool checkSignature( const std::string& signature ) const;
+    virtual bool checkSignature( const cv::String& signature ) const;
     virtual ImageDecoder newDecoder() const;
 
 protected:
     int  m_width;  // width  of the image ( filled by readHeader )
     int  m_height; // height of the image ( filled by readHeader )
     int  m_type;
-    std::string m_filename;
+    cv::String m_filename;
-    std::string m_signature;
+    cv::String m_signature;
     Mat m_buf;
     bool m_buf_supported;
 };
@@ -93,23 +93,23 @@ public:
     virtual ~BaseImageEncoder() {};
     virtual bool isFormatSupported( int depth ) const;
 
-    virtual bool setDestination( const std::string& filename );
+    virtual bool setDestination( const cv::String& filename );
     virtual bool setDestination( std::vector<uchar>& buf );
     virtual bool write( const Mat& img, const std::vector<int>& params ) = 0;
 
-    virtual std::string getDescription() const;
+    virtual cv::String getDescription() const;
     virtual ImageEncoder newEncoder() const;
 
     virtual void throwOnEror() const;
 
 protected:
-    std::string m_description;
+    cv::String m_description;
 
-    std::string m_filename;
+    cv::String m_filename;
     std::vector<uchar>* m_buf;
     bool m_buf_supported;
 
-    std::string m_last_error;
+    cv::String m_last_error;
 };
 
 }

modules/highgui/src/grfmt_jpeg2000.cpp

@@ -82,7 +82,7 @@ static JasperInitializer initialize_jasper;
 
 Jpeg2KDecoder::Jpeg2KDecoder()
 {
-    m_signature = '\0' + std::string() + '\0' + std::string() + '\0' + std::string("\x0cjP  \r\n\x87\n");
+    m_signature = '\0' + cv::String() + '\0' + cv::String() + '\0' + cv::String("\x0cjP  \r\n\x87\n");
     m_stream = 0;
     m_image = 0;
 }

modules/highgui/src/grfmt_pxm.cpp

@@ -107,7 +107,7 @@ size_t PxMDecoder::signatureLength() const
     return 3;
 }
 
-bool PxMDecoder::checkSignature( const std::string& signature ) const
+bool PxMDecoder::checkSignature( const cv::String& signature ) const
 {
     return signature.size() >= 3 && signature[0] == 'P' &&
            '1' <= signature[1] && signature[1] <= '6' &&

modules/highgui/src/grfmt_pxm.hpp

@@ -61,7 +61,7 @@ public:
     void  close();
 
     size_t signatureLength() const;
-    bool checkSignature( const std::string& signature ) const;
+    bool checkSignature( const cv::String& signature ) const;
     ImageDecoder newDecoder() const;
 
 protected:

modules/highgui/src/grfmt_tiff.cpp

@@ -94,7 +94,7 @@ size_t TiffDecoder::signatureLength() const
     return 4;
 }
 
-bool TiffDecoder::checkSignature( const std::string& signature ) const
+bool TiffDecoder::checkSignature( const cv::String& signature ) const
 {
     return signature.size() >= 4 &&
         (memcmp(signature.c_str(), fmtSignTiffII, 4) == 0 ||

modules/highgui/src/grfmt_tiff.hpp

@@ -102,7 +102,7 @@ public:
     void  close();
 
     size_t signatureLength() const;
-    bool checkSignature( const std::string& signature ) const;
+    bool checkSignature( const cv::String& signature ) const;
     ImageDecoder newDecoder() const;
 
 protected:

modules/highgui/src/grfmt_webp.cpp

@@ -71,7 +71,7 @@ ImageDecoder WebPDecoder::newDecoder() const
     return new WebPDecoder;
 }
 
-bool WebPDecoder::checkSignature( const std::string& signature ) const
+bool WebPDecoder::checkSignature( const cv::String& signature ) const
 {
     size_t len = signatureLength();
     bool ret = false;

modules/highgui/src/grfmt_webp.hpp

@@ -60,7 +60,7 @@ public:
     bool readData( Mat& img );
     bool readHeader();
     void close();
-    bool checkSignature( const std::string& signature ) const;
+    bool checkSignature( const cv::String& signature ) const;
 
     ImageDecoder newDecoder() const;
 

modules/highgui/src/loadsave.cpp

@@ -96,7 +96,7 @@ struct ImageCodecInitializer
 
 static ImageCodecInitializer codecs;
 
-static ImageDecoder findDecoder( const std::string& filename )
+static ImageDecoder findDecoder( const cv::String& filename )
 {
     size_t i, maxlen = 0;
     for( i = 0; i < codecs.decoders.size(); i++ )
@@ -108,8 +108,8 @@ static ImageDecoder findDecoder( const std::string& filename )
     FILE* f= fopen( filename.c_str(), "rb" );
     if( !f )
         return ImageDecoder();
-    std::string signature(maxlen, ' ');
+    cv::String signature(maxlen, ' ');
-    maxlen = fread( &signature[0], 1, maxlen, f );
+    maxlen = fread( (void*)signature.c_str(), 1, maxlen, f );
     fclose(f);
     signature = signature.substr(0, maxlen);
 
@@ -137,8 +137,8 @@ static ImageDecoder findDecoder( const Mat& buf )
 
     size_t bufSize = buf.rows*buf.cols*buf.elemSize();
     maxlen = std::min(maxlen, bufSize);
-    std::string signature(maxlen, ' ');
+    cv::String signature(maxlen, ' ');
-    memcpy( &signature[0], buf.data, maxlen );
+    memcpy( (void*)signature.c_str(), buf.data, maxlen );
 
     for( i = 0; i < codecs.decoders.size(); i++ )
     {
@@ -149,7 +149,7 @@ static ImageDecoder findDecoder( const Mat& buf )
     return ImageDecoder();
 }
 
-static ImageEncoder findEncoder( const std::string& _ext )
+static ImageEncoder findEncoder( const cv::String& _ext )
 {
     if( _ext.size() <= 1 )
         return ImageEncoder();
@@ -163,7 +163,7 @@ static ImageEncoder findEncoder( const std::string& _ext )
 
     for( size_t i = 0; i < codecs.encoders.size(); i++ )
     {
-        std::string description = codecs.encoders[i]->getDescription();
+        cv::String description = codecs.encoders[i]->getDescription();
         const char* descr = strchr( description.c_str(), '(' );
 
         while( descr )
@@ -191,7 +191,7 @@ static ImageEncoder findEncoder( const std::string& _ext )
 enum { LOAD_CVMAT=0, LOAD_IMAGE=1, LOAD_MAT=2 };
 
 static void*
-imread_( const std::string& filename, int flags, int hdrtype, Mat* mat=0 )
+imread_( const cv::String& filename, int flags, int hdrtype, Mat* mat=0 )
 {
     IplImage* image = 0;
     CvMat *matrix = 0;
@@ -253,14 +253,14 @@ imread_( const std::string& filename, int flags, int hdrtype, Mat* mat=0 )
         hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
 }
 
-Mat imread( const std::string& filename, int flags )
+Mat imread( const cv::String& filename, int flags )
 {
     Mat img;
     imread_( filename, flags, LOAD_MAT, &img );
     return img;
 }
 
-static bool imwrite_( const std::string& filename, const Mat& image,
+static bool imwrite_( const cv::String& filename, const Mat& image,
                       const std::vector<int>& params, bool flipv )
 {
     Mat temp;
@@ -292,7 +292,7 @@ static bool imwrite_( const std::string& filename, const Mat& image,
     return code;
 }
 
-bool imwrite( const std::string& filename, InputArray _img,
+bool imwrite( const cv::String& filename, InputArray _img,
               const std::vector<int>& params )
 {
     Mat img = _img.getMat();
@@ -306,7 +306,7 @@ imdecode_( const Mat& buf, int flags, int hdrtype, Mat* mat=0 )
     IplImage* image = 0;
     CvMat *matrix = 0;
     Mat temp, *data = &temp;
-    std::string filename;
+    cv::String filename;
 
     ImageDecoder decoder = findDecoder(buf);
     if( decoder.empty() )
@@ -400,7 +400,7 @@ Mat imdecode( InputArray _buf, int flags, Mat* dst )
     return *dst;
 }
 
-bool imencode( const std::string& ext, InputArray _image,
+bool imencode( const cv::String& ext, InputArray _image,
                std::vector<uchar>& buf, const std::vector<int>& params )
 {
     Mat image = _image.getMat();
@@ -429,7 +429,7 @@ bool imencode( const std::string& ext, InputArray _image,
     }
     else
     {
-        std::string filename = tempfile();
+        cv::String filename = tempfile();
         code = encoder->setDestination(filename);
         CV_Assert( code );
 

modules/highgui/src/window.cpp

@@ -153,12 +153,12 @@ CV_IMPL double cvGetWindowProperty(const char* name, int prop_id)
     }
 }
 
-void cv::namedWindow( const std::string& winname, int flags )
+void cv::namedWindow( const cv::String& winname, int flags )
 {
     cvNamedWindow( winname.c_str(), flags );
 }
 
-void cv::destroyWindow( const std::string& winname )
+void cv::destroyWindow( const cv::String& winname )
 {
     cvDestroyWindow( winname.c_str() );
 }
@@ -168,22 +168,22 @@ void cv::destroyAllWindows()
     cvDestroyAllWindows();
 }
 
-void cv::resizeWindow( const std::string& winname, int width, int height )
+void cv::resizeWindow( const cv::String& winname, int width, int height )
 {
     cvResizeWindow( winname.c_str(), width, height );
 }
 
-void cv::moveWindow( const std::string& winname, int x, int y )
+void cv::moveWindow( const cv::String& winname, int x, int y )
 {
     cvMoveWindow( winname.c_str(), x, y );
 }
 
-void cv::setWindowProperty(const std::string& winname, int prop_id, double prop_value)
+void cv::setWindowProperty(const cv::String& winname, int prop_id, double prop_value)
 {
     cvSetWindowProperty( winname.c_str(), prop_id, prop_value);
 }
 
-double cv::getWindowProperty(const std::string& winname, int prop_id)
+double cv::getWindowProperty(const cv::String& winname, int prop_id)
 {
     return cvGetWindowProperty(winname.c_str(), prop_id);
 }
@@ -193,7 +193,7 @@ int cv::waitKey(int delay)
     return cvWaitKey(delay);
 }
 
-int cv::createTrackbar(const std::string& trackbarName, const std::string& winName,
+int cv::createTrackbar(const cv::String& trackbarName, const cv::String& winName,
                    int* value, int count, TrackbarCallback callback,
                    void* userdata)
 {
@@ -201,17 +201,17 @@ int cv::createTrackbar(const std::string& trackbarName, const std::string& winNa
                              value, count, callback, userdata);
 }
 
-void cv::setTrackbarPos( const std::string& trackbarName, const std::string& winName, int value )
+void cv::setTrackbarPos( const cv::String& trackbarName, const cv::String& winName, int value )
 {
     cvSetTrackbarPos(trackbarName.c_str(), winName.c_str(), value );
 }
 
-int cv::getTrackbarPos( const std::string& trackbarName, const std::string& winName )
+int cv::getTrackbarPos( const cv::String& trackbarName, const cv::String& winName )
 {
     return cvGetTrackbarPos(trackbarName.c_str(), winName.c_str());
 }
 
-void cv::setMouseCallback( const std::string& windowName, MouseCallback onMouse, void* param)
+void cv::setMouseCallback( const cv::String& windowName, MouseCallback onMouse, void* param)
 {
     cvSetMouseCallback(windowName.c_str(), onMouse, param);
 }
@@ -223,17 +223,17 @@ int cv::startWindowThread()
 
 // OpenGL support
 
-void cv::setOpenGlDrawCallback(const std::string& name, OpenGlDrawCallback callback, void* userdata)
+void cv::setOpenGlDrawCallback(const cv::String& name, OpenGlDrawCallback callback, void* userdata)
 {
     cvSetOpenGlDrawCallback(name.c_str(), callback, userdata);
 }
 
-void cv::setOpenGlContext(const std::string& windowName)
+void cv::setOpenGlContext(const cv::String& windowName)
 {
     cvSetOpenGlContext(windowName.c_str());
 }
 
-void cv::updateWindow(const std::string& windowName)
+void cv::updateWindow(const cv::String& windowName)
 {
     cvUpdateWindow(windowName.c_str());
 }
@@ -241,9 +241,9 @@ void cv::updateWindow(const std::string& windowName)
 #ifdef HAVE_OPENGL
 namespace
 {
-    std::map<std::string, cv::ogl::Texture2D> wndTexs;
+    std::map<cv::String, cv::ogl::Texture2D> wndTexs;
-    std::map<std::string, cv::ogl::Texture2D> ownWndTexs;
+    std::map<cv::String, cv::ogl::Texture2D> ownWndTexs;
-    std::map<std::string, cv::ogl::Buffer> ownWndBufs;
+    std::map<cv::String, cv::ogl::Buffer> ownWndBufs;
 
     void glDrawTextureCallback(void* userdata)
     {
@@ -254,7 +254,7 @@ namespace
 }
 #endif // HAVE_OPENGL
 
-void cv::imshow( const std::string& winname, InputArray _img )
+void cv::imshow( const cv::String& winname, InputArray _img )
 {
 #ifndef HAVE_OPENGL
     Mat img = _img.getMat();
@@ -342,23 +342,23 @@ CV_IMPL void cvUpdateWindow(const char*)
 
 #if defined (HAVE_QT)
 
-CvFont cv::fontQt(const std::string& nameFont, int pointSize, Scalar color, int weight,  int style, int /*spacing*/)
+CvFont cv::fontQt(const cv::String& nameFont, int pointSize, Scalar color, int weight,  int style, int /*spacing*/)
 {
 return cvFontQt(nameFont.c_str(), pointSize,color,weight, style);
 }
 
-void cv::addText( const Mat& img, const std::string& text, Point org, CvFont font)
+void cv::addText( const Mat& img, const cv::String& text, Point org, CvFont font)
 {
     CvMat _img = img;
     cvAddText( &_img, text.c_str(), org,&font);
 }
 
-void cv::displayStatusBar(const std::string& name,  const std::string& text, int delayms)
+void cv::displayStatusBar(const cv::String& name,  const cv::String& text, int delayms)
 {
     cvDisplayStatusBar(name.c_str(),text.c_str(), delayms);
 }
 
-void cv::displayOverlay(const std::string& name,  const std::string& text, int delayms)
+void cv::displayOverlay(const cv::String& name,  const cv::String& text, int delayms)
 {
     cvDisplayOverlay(name.c_str(),text.c_str(), delayms);
 }
@@ -373,40 +373,40 @@ void cv::stopLoop()
     cvStopLoop();
 }
 
-void cv::saveWindowParameters(const std::string& windowName)
+void cv::saveWindowParameters(const cv::String& windowName)
 {
     cvSaveWindowParameters(windowName.c_str());
 }
 
-void cv::loadWindowParameters(const std::string& windowName)
+void cv::loadWindowParameters(const cv::String& windowName)
 {
     cvLoadWindowParameters(windowName.c_str());
 }
 
-int cv::createButton(const std::string& button_name, ButtonCallback on_change, void* userdata, int button_type , bool initial_button_state  )
+int cv::createButton(const cv::String& button_name, ButtonCallback on_change, void* userdata, int button_type , bool initial_button_state  )
 {
     return cvCreateButton(button_name.c_str(), on_change, userdata, button_type , initial_button_state );
 }
 
 #else
 
-CvFont cv::fontQt(const std::string&, int, Scalar, int,  int, int)
+CvFont cv::fontQt(const cv::String&, int, Scalar, int,  int, int)
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
     return CvFont();
 }
 
-void cv::addText( const Mat&, const std::string&, Point, CvFont)
+void cv::addText( const Mat&, const cv::String&, Point, CvFont)
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
 
-void cv::displayStatusBar(const std::string&,  const std::string&, int)
+void cv::displayStatusBar(const cv::String&,  const cv::String&, int)
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
 
-void cv::displayOverlay(const std::string&,  const std::string&, int )
+void cv::displayOverlay(const cv::String&,  const cv::String&, int )
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
@@ -422,17 +422,17 @@ void cv::stopLoop()
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
 
-void cv::saveWindowParameters(const std::string&)
+void cv::saveWindowParameters(const cv::String&)
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
 
-void cv::loadWindowParameters(const std::string&)
+void cv::loadWindowParameters(const cv::String&)
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
 }
 
-int cv::createButton(const std::string&, ButtonCallback, void*, int , bool )
+int cv::createButton(const cv::String&, ButtonCallback, void*, int , bool )
 {
     CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
     return 0;