From: Andrey Kamaev <andrey.kamaev@itseez.com>
Date: Mon, 25 Mar 2013 12:01:23 +0000 (+0400)
Subject: Move implementation of cv::String methods out of class definition
X-Git-Tag: submit/tizen_ivi/20141117.190038~2^2~1112^2~2
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=78a843e8ac114a423512c5a816c9f21eaa9741f4;p=profile%2Fivi%2Fopencv.git

Move implementation of cv::String methods out of class definition
---

diff --git a/modules/core/include/opencv2/core/cvstd.hpp b/modules/core/include/opencv2/core/cvstd.hpp
index e5af0f2..30e4674 100644
--- a/modules/core/include/opencv2/core/cvstd.hpp
+++ b/modules/core/include/opencv2/core/cvstd.hpp
@@ -44,11 +44,15 @@
 #ifndef __OPENCV_CORE_CVSTD_HPP__
 #define __OPENCV_CORE_CVSTD_HPP__
 
-#include <cstddef>
-#include <cstring>
+#ifndef __cplusplus
+#  error cvstd.hpp header must be compiled as C++
+#endif
 
 #include "opencv2/core/cvdef.h"
 
+#include <cstddef>
+#include <cstring>
+
 #ifndef OPENCV_NOSTL
 #  include <string>
 #endif
@@ -96,299 +100,389 @@ public:
     typedef const char* const_pointer;
     typedef ptrdiff_t difference_type;
     typedef size_t size_type;
-
     typedef char* iterator;
     typedef const char* const_iterator;
 
     static const size_t npos = size_t(-1);
 
-    explicit String() : cstr_(0), len_(0) {}
+    explicit String();
+    String(const String& str);
+    String(const String& str, size_t pos, size_t len = npos);
+    String(const char* s);
+    String(const char* s, size_t n);
+    String(size_t n, char c);
+    String(const char* first, const char* last);
+    template<typename Iterator> String(Iterator first, Iterator last);
+    explicit String(const FileNode& fn);
+    ~String();
 
-    String(const String& str) : cstr_(str.cstr_), len_(str.len_)
-    {
-        if (cstr_) CV_XADD(((int*)cstr_)-1, 1);
-    }
+    String& operator=(const String& str);
+    String& operator=(const char* s);
+    String& operator=(char c);
 
-    String(const String& str, size_t pos, size_t len = npos) : cstr_(0), len_(0)
-    {
-        pos = min(pos, str.len_);
-        len = min(str.len_ - pos, len);
-        if (!len) return;
-        if (len == str.len_)
-        {
-            CV_XADD(((int*)str.cstr_)-1, 1);
-            cstr_ = str.cstr_;
-            len_ = str.len_;
-            return;
-        }
-        memcpy(allocate(len), str.cstr_ + pos, len);
-    }
+    size_t size() const;
+    size_t length() const;
 
-    String(const char* s): cstr_(0), len_(0)
-    {
-        if (!s) return;
-        size_t len = strlen(s);
-        memcpy(allocate(len), s, len);
-    }
+    char operator[](size_t idx) const;
+    char operator[](int idx) const;
 
-    String(const char* s, size_t n): cstr_(0), len_(0)
-    {
-        if (!n) return;
-        memcpy(allocate(n), s, n);
-    }
+    const char* begin() const;
+    const char* end() const;
 
-    String(size_t n, char c): cstr_(0), len_(0)
-    {
-        memset(allocate(n), c, n);
-    }
+    const char* c_str() const;
 
-    String(const char* first, const char* last): cstr_(0), len_(0)
-    {
-        size_t len = (size_t)(last - first);
-        memcpy(allocate(len), first, len);
-    }
+    bool empty() const;
+    void clear();
 
-    template<typename Iterator>
-    String(Iterator first, Iterator last): cstr_(0), len_(0)
-    {
-        size_t len = (size_t)(last - first);
-        char* str = allocate(len);
-        while (first != last)
-        {
-            *str++ = *first;
-            ++first;
-        }
-    }
+    int compare(const char* s) const;
+    int compare(const String& str) const;
+
+    void swap(String& str);
+    String substr(size_t pos = 0, size_t len = npos) const;
+
+    size_t find(const char* s, size_t pos, size_t n) const;
+    size_t find(char c, size_t pos = 0) const;
+    size_t find(const String& str, size_t pos = 0) const;
+    size_t find(const char* s, size_t pos = 0) const;
+
+    size_t rfind(const char* s, size_t pos, size_t n) const;
+    size_t rfind(char c, size_t pos = npos) const;
+    size_t rfind(const String& str, size_t pos = npos) const;
+    size_t rfind(const char* s, size_t pos = npos) const;
+
+    size_t find_first_of(const char* s, size_t pos, size_t n) const;
+    size_t find_first_of(char c, size_t pos = 0) const;
+    size_t find_first_of(const String& str, size_t pos = 0) const;
+    size_t find_first_of(const char* s, size_t pos = 0) const;
+
+    size_t find_last_of(const char* s, size_t pos, size_t n) const;
+    size_t find_last_of(char c, size_t pos = npos) const;
+    size_t find_last_of(const String& str, size_t pos = npos) const;
+    size_t find_last_of(const char* s, size_t pos = npos) const;
+
+    friend String operator+ (const String& lhs, const String& rhs);
+    friend String operator+ (const String& lhs, const char*   rhs);
+    friend String operator+ (const char*   lhs, const String& rhs);
+    friend String operator+ (const String& lhs, char          rhs);
+    friend String operator+ (char          lhs, const String& rhs);
+
+#ifndef OPENCV_NOSTL
+    String(const std::string& str);
+    String(const std::string& str, size_t pos, size_t len = npos);
+    String& operator=(const std::string& str);
+    operator std::string() const;
+
+    friend String operator+ (const String& lhs, const std::string& rhs);
+    friend String operator+ (const std::string& lhs, const String& rhs);
+#endif
+
+private:
+    char*  cstr_;
+    size_t len_;
+
+    char* allocate(size_t len); // len without trailing 0
+    void deallocate();
+};
 
-    ~String() { deallocate(); }
+// **************************** cv::String implementation ****************************
 
-    String& operator=(const String& str)
+inline String::String() : cstr_(0), len_(0)
+{
+}
+
+inline String::String(const String& str) : cstr_(str.cstr_), len_(str.len_)
+{
+    if (cstr_)
+        CV_XADD(((int*)cstr_)-1, 1);
+}
+
+inline String::String(const String& str, size_t pos, size_t len) : cstr_(0), len_(0)
+{
+    pos = min(pos, str.len_);
+    len = min(str.len_ - pos, len);
+    if (!len) return;
+    if (len == str.len_)
     {
-        deallocate();
-        if (str.cstr_) CV_XADD(((int*)str.cstr_)-1, 1);
+        CV_XADD(((int*)str.cstr_)-1, 1);
         cstr_ = str.cstr_;
         len_ = str.len_;
-        return *this;
+        return;
     }
+    memcpy(allocate(len), str.cstr_ + pos, len);
+}
 
-    String& operator=(const char* s)
-    {
-        deallocate();
-        if (!s) return *this;
-        size_t len = strlen(s);
-        memcpy(allocate(len), s, len);
-        return *this;
-    }
+inline String::String(const char* s) : cstr_(0), len_(0)
+{
+    if (!s) return;
+    size_t len = strlen(s);
+    memcpy(allocate(len), s, len);
+}
+
+inline String::String(const char* s, size_t n) : cstr_(0), len_(0)
+{
+    if (!n) return;
+    memcpy(allocate(n), s, n);
+}
+
+inline String::String(size_t n, char c) : cstr_(0), len_(0)
+{
+    memset(allocate(n), c, n);
+}
+
+inline String::String(const char* first, const char* last) : cstr_(0), len_(0)
+{
+    size_t len = (size_t)(last - first);
+    memcpy(allocate(len), first, len);
+}
 
-    String& operator=(char c)
+template<typename Iterator>
+inline String::String(Iterator first, Iterator last) : cstr_(0), len_(0)
+{
+    size_t len = (size_t)(last - first);
+    char* str = allocate(len);
+    while (first != last)
     {
-        deallocate();
-        allocate(1)[0] = c;
-        return *this;
+        *str++ = *first;
+        ++first;
     }
+}
 
-    size_t size() const { return len_; }
-    size_t length() const { return len_; }
+inline String::~String()
+{
+    deallocate();
+}
 
-    char operator[](size_t idx) const { return cstr_[idx]; }
-    char operator[](int idx) const    { return cstr_[idx]; }
+inline String& String::operator=(const String& str)
+{
+    deallocate();
+    if (str.cstr_) CV_XADD(((int*)str.cstr_)-1, 1);
+    cstr_ = str.cstr_;
+    len_ = str.len_;
+    return *this;
+}
 
-    const char* begin() const { return cstr_; }
-    const char* end() const { return len_ ? cstr_ + 1 : 0; }
+inline String& String::operator=(const char* s)
+{
+    deallocate();
+    if (!s) return *this;
+    size_t len = strlen(s);
+    memcpy(allocate(len), s, len);
+    return *this;
+}
 
-    bool empty() const { return len_ == 0; }
+inline String& String::operator=(char c)
+{
+    deallocate();
+    allocate(1)[0] = c;
+    return *this;
+}
 
-    const char* c_str() const { return cstr_ ? cstr_ : ""; }
+inline size_t String::size() const
+{
+    return len_;
+}
 
-    void swap(String& str)
-    {
-        cv::swap(cstr_, str.cstr_);
-        cv::swap(len_, str.len_);
-    }
+inline size_t String::length() const
+{
+    return len_;
+}
 
-    void clear() { deallocate(); }
+inline char String::operator[](size_t idx) const
+{
+    return cstr_[idx];
+}
 
-    int compare(const char* s) const
-    {
-        if (cstr_ == s) return 0;
+inline char String::operator[](int idx) const
+{
+    return cstr_[idx];
+}
 
-        return strcmp(c_str(), s);
-    }
+inline const char* String::begin() const
+{
+    return cstr_;
+}
 
-    int compare(const String& str) const
-    {
-        if (cstr_ == str.cstr_) return 0;
+inline const char* String::end() const
+{
+    return len_ ? cstr_ + 1 : 0;
+}
 
-        return strcmp(c_str(), str.c_str());
-    }
+inline bool String::empty() const
+{
+    return len_ == 0;
+}
 
-    String substr(size_t pos = 0, size_t len = npos) const
-    {
-        return String(*this, pos, len);
-    }
+inline const char* String::c_str() const
+{
+    return cstr_ ? cstr_ : "";
+}
 
-    size_t find(const char* s, size_t pos, size_t n) const
-    {
-        if (n == 0 || pos + n > len_) return npos;
-        const char* lmax = cstr_ + len_ - n;
-        for (const char* i = cstr_ + pos; i <= lmax; ++i)
-        {
-            size_t j = 0;
-            while (j < n && s[j] == i[j]) ++j;
-            if (j == n) return (size_t)(i - cstr_);
-        }
-        return npos;
-    }
+inline void String::swap(String& str)
+{
+    cv::swap(cstr_, str.cstr_);
+    cv::swap(len_, str.len_);
+}
 
-    size_t find(char c, size_t pos = 0) const
-    {
-        return find(&c, pos, 1);
-    }
+inline void String::clear()
+{
+    deallocate();
+}
 
-    size_t find(const String& str, size_t pos = 0) const
-    {
-        return find(str.c_str(), pos, str.len_);
-    }
+inline int String::compare(const char* s) const
+{
+    if (cstr_ == s) return 0;
+    return strcmp(c_str(), s);
+}
 
-    size_t find(const char* s, size_t pos = 0) const
-    {
-        if (pos >= len_ || !s[0]) return npos;
-        const char* lmax = cstr_ + len_;
-        for (const char* i = cstr_ + pos; i < lmax; ++i)
-        {
-            size_t j = 0;
-            while (s[j] && s[j] == i[j])
-            {   if(i + j >= lmax) return npos;
-                ++j;
-            }
-            if (!s[j]) return (size_t)(i - cstr_);
-        }
-        return npos;
-    }
+inline int String::compare(const String& str) const
+{
+    if (cstr_ == str.cstr_) return 0;
+    return strcmp(c_str(), str.c_str());
+}
 
-    size_t rfind(const char* s, size_t pos, size_t n) const
-    {
-        if (n > len_) return npos;
-        if (pos > len_ - n) pos = len_ - n;
-        for (const char* i = cstr_ + pos; i >= cstr_; --i)
-        {
-            size_t j = 0;
-            while (j < n && s[j] == i[j]) ++j;
-            if (j == n) return (size_t)(i - cstr_);
-        }
-        return npos;
-    }
+inline String String::substr(size_t pos, size_t len) const
+{
+    return String(*this, pos, len);
+}
 
-    size_t rfind(char c, size_t pos = npos) const
+inline size_t String::find(const char* s, size_t pos, size_t n) const
+{
+    if (n == 0 || pos + n > len_) return npos;
+    const char* lmax = cstr_ + len_ - n;
+    for (const char* i = cstr_ + pos; i <= lmax; ++i)
     {
-        return rfind(&c, pos, 1);
+        size_t j = 0;
+        while (j < n && s[j] == i[j]) ++j;
+        if (j == n) return (size_t)(i - cstr_);
     }
+    return npos;
+}
 
-    size_t rfind(const String& str, size_t pos = npos) const
-    {
-        return rfind(str.c_str(), pos, str.len_);
-    }
+inline size_t String::find(char c, size_t pos) const
+{
+    return find(&c, pos, 1);
+}
 
-    size_t rfind(const char* s, size_t pos = npos) const
-    {
-        return rfind(s, pos, strlen(s));
-    }
+inline size_t String::find(const String& str, size_t pos) const
+{
+    return find(str.c_str(), pos, str.len_);
+}
 
-    size_t find_first_of(const char* s, size_t pos, size_t n) const
+inline size_t String::find(const char* s, size_t pos) const
+{
+    if (pos >= len_ || !s[0]) return npos;
+    const char* lmax = cstr_ + len_;
+    for (const char* i = cstr_ + pos; i < lmax; ++i)
     {
-        if (n == 0 || pos + n > len_) return npos;
-        const char* lmax = cstr_ + len_;
-        for (const char* i = cstr_ + pos; i < lmax; ++i)
-        {
-            for (size_t j = 0; j < n; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
+        size_t j = 0;
+        while (s[j] && s[j] == i[j])
+        {   if(i + j >= lmax) return npos;
+            ++j;
         }
-        return npos;
+        if (!s[j]) return (size_t)(i - cstr_);
     }
+    return npos;
+}
 
-    size_t find_first_of(char c, size_t pos = 0) const
+inline size_t String::rfind(const char* s, size_t pos, size_t n) const
+{
+    if (n > len_) return npos;
+    if (pos > len_ - n) pos = len_ - n;
+    for (const char* i = cstr_ + pos; i >= cstr_; --i)
     {
-        return find_first_of(&c, pos, 1);
+        size_t j = 0;
+        while (j < n && s[j] == i[j]) ++j;
+        if (j == n) return (size_t)(i - cstr_);
     }
+    return npos;
+}
 
-    size_t find_first_of(const String& str, size_t pos = 0) const
-    {
-        return find_first_of(str.c_str(), pos, str.len_);
-    }
+inline size_t String::rfind(char c, size_t pos) const
+{
+    return rfind(&c, pos, 1);
+}
 
-    size_t find_first_of(const char* s, size_t pos = 0) const
-    {
-        if (pos >= len_ || !s[0]) return npos;
-        const char* lmax = cstr_ + len_;
-        for (const char* i = cstr_ + pos; i < lmax; ++i)
-        {
-            for (size_t j = 0; s[j]; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
-        }
-        return npos;
-    }
+inline size_t String::rfind(const String& str, size_t pos) const
+{
+    return rfind(str.c_str(), pos, str.len_);
+}
 
-    size_t find_last_of(const char* s, size_t pos, size_t n) const
-    {
-        if (pos >= len_) pos = len_ - 1;
-        for (const char* i = cstr_ + pos; i >= cstr_; --i)
-        {
-            for (size_t j = 0; j < n; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
-        }
-        return npos;
-    }
+inline size_t String::rfind(const char* s, size_t pos) const
+{
+    return rfind(s, pos, strlen(s));
+}
 
-    size_t find_last_of(char c, size_t pos = npos) const
+inline size_t String::find_first_of(const char* s, size_t pos, size_t n) const
+{
+    if (n == 0 || pos + n > len_) return npos;
+    const char* lmax = cstr_ + len_;
+    for (const char* i = cstr_ + pos; i < lmax; ++i)
     {
-        return find_last_of(&c, pos, 1);
+        for (size_t j = 0; j < n; ++j)
+            if (s[j] == *i)
+                return (size_t)(i - cstr_);
     }
+    return npos;
+}
+
+inline size_t String::find_first_of(char c, size_t pos) const
+{
+    return find_first_of(&c, pos, 1);
+}
 
-    size_t find_last_of(const String& str, size_t pos = npos) const
+inline size_t String::find_first_of(const String& str, size_t pos) const
+{
+    return find_first_of(str.c_str(), pos, str.len_);
+}
+
+inline size_t String::find_first_of(const char* s, size_t pos) const
+{
+    if (pos >= len_ || !s[0]) return npos;
+    const char* lmax = cstr_ + len_;
+    for (const char* i = cstr_ + pos; i < lmax; ++i)
     {
-        return find_last_of(str.c_str(), pos, str.len_);
+        for (size_t j = 0; s[j]; ++j)
+            if (s[j] == *i)
+                return (size_t)(i - cstr_);
     }
+    return npos;
+}
 
-    size_t find_last_of(const char* s, size_t pos = npos) const
+inline size_t String::find_last_of(const char* s, size_t pos, size_t n) const
+{
+    if (pos >= len_) pos = len_ - 1;
+    for (const char* i = cstr_ + pos; i >= cstr_; --i)
     {
-        if (pos >= len_) pos = len_ - 1;
-        for (const char* i = cstr_ + pos; i >= cstr_; --i)
-        {
-            for (size_t j = 0; s[j]; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
-        }
-        return npos;
+        for (size_t j = 0; j < n; ++j)
+            if (s[j] == *i)
+                return (size_t)(i - cstr_);
     }
+    return npos;
+}
 
-    friend String operator+ (const String& lhs, const String& rhs);
-    friend String operator+ (const String& lhs, const char*   rhs);
-    friend String operator+ (const char*   lhs, const String& rhs);
-    friend String operator+ (const String& lhs, char          rhs);
-    friend String operator+ (char          lhs, const String& rhs);
-
-#ifndef OPENCV_NOSTL
-    String(const std::string& str);
-    String(const std::string& str, size_t pos, size_t len = npos);
-    String& operator=(const std::string& str);
-    operator std::string() const;
-
-    friend String operator+ (const String& lhs, const std::string& rhs);
-    friend String operator+ (const std::string& lhs, const String& rhs);
-#endif
+inline size_t String::find_last_of(char c, size_t pos) const
+{
+    return find_last_of(&c, pos, 1);
+}
 
-    explicit String(const FileNode& fn);
+inline size_t String::find_last_of(const String& str, size_t pos) const
+{
+    return find_last_of(str.c_str(), pos, str.len_);
+}
 
-private:
-    char*  cstr_;
-    size_t len_;
+inline size_t String::find_last_of(const char* s, size_t pos) const
+{
+    if (pos >= len_) pos = len_ - 1;
+    for (const char* i = cstr_ + pos; i >= cstr_; --i)
+    {
+        for (size_t j = 0; s[j]; ++j)
+            if (s[j] == *i)
+                return (size_t)(i - cstr_);
+    }
+    return npos;
+}
 
-    char* allocate(size_t len); // len_ without trailing 0
-    void deallocate();
-};
+// ************************* cv::String non-member functions *************************
 
 inline String operator+ (const String& lhs, const String& rhs)
 {