Merge pull request #702 from taka-no-me:refactor_core_headers

modules/core/include/opencv2/core/cvdef.h

@@ -112,15 +112,15 @@
 #define CV_HARDWARE_MAX_FEATURE 255
 
 #if defined __SSE2__ || defined _M_X64  || (defined _M_IX86_FP && _M_IX86_FP >= 2)
-#  include "emmintrin.h"
+#  include <emmintrin.h>
 #  define CV_SSE 1
 #  define CV_SSE2 1
 #  if defined __SSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
-#    include "pmmintrin.h"
+#    include <pmmintrin.h>
 #    define CV_SSE3 1
 #  endif
 #  if defined __SSSE3__  || (defined _MSC_VER && _MSC_VER >= 1500)
-#    include "tmmintrin.h"
+#    include <tmmintrin.h>
 #    define CV_SSSE3 1
 #  endif
 #  if defined __SSE4_1__ || (defined _MSC_VER && _MSC_VER >= 1500)
@@ -187,7 +187,13 @@
 */
 
 #if !defined _MSC_VER && !defined __BORLANDC__
-#  include <stdint.h>
+#  if defined __cplusplus && __cplusplus >= 201103L
+#    include <cstdint>
+#  else
+#    include <stdint.h>
+#  endif
+#else
+   typedef unsigned uint;
 #endif
 
 typedef signed char schar;
@@ -318,6 +324,8 @@ typedef signed char schar;
 
 #if defined __BORLANDC__
 #  include <fastmath.h>
+#elif defined __cplusplus
+#  include <cmath>
 #else
 #  include <math.h>
 #endif
@@ -414,7 +422,7 @@ CV_INLINE int cvIsInf( double value )
 #      define CV_XADD(addr, delta) __atomic_fetch_add((_Atomic(int)*)(addr), delta, 4)
 #    endif
 #  else
-#    ifdef __ATOMIC_ACQ_REL
+#    if defined __ATOMIC_ACQ_REL && !defined __clang__
        // version for gcc >= 4.7
 #      define CV_XADD(addr, delta) __atomic_fetch_add(addr, delta, __ATOMIC_ACQ_REL)
 #    else

modules/core/include/opencv2/core/cvstd.hpp

@@ -44,11 +44,15 @@
 #ifndef __OPENCV_CORE_CVSTD_HPP__
 #define __OPENCV_CORE_CVSTD_HPP__
 
-#include <cstddef>
+#ifndef __cplusplus
-#include <cstring>
+#  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_)
+    String& operator=(const String& str);
-    {
+    String& operator=(const char* s);
-        if (cstr_) CV_XADD(((int*)cstr_)-1, 1);
+    String& operator=(char c);
-    }
 
-    String(const String& str, size_t pos, size_t len = npos) : cstr_(0), len_(0)
+    size_t size() const;
-    {
+    size_t length() const;
-        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);
-    }
 
-    String(const char* s): cstr_(0), len_(0)
+    char operator[](size_t idx) const;
-    {
+    char operator[](int idx) const;
-        if (!s) return;
-        size_t len = strlen(s);
-        memcpy(allocate(len), s, len);
-    }
 
-    String(const char* s, size_t n): cstr_(0), len_(0)
+    const char* begin() const;
-    {
+    const char* end() const;
-        if (!n) return;
-        memcpy(allocate(n), s, n);
-    }
 
-    String(size_t n, char c): cstr_(0), len_(0)
+    const char* c_str() const;
-    {
-        memset(allocate(n), c, n);
-    }
 
-    String(const char* first, const char* last): cstr_(0), len_(0)
+    bool empty() const;
-    {
+    void clear();
-        size_t len = (size_t)(last - first);
-        memcpy(allocate(len), first, len);
-    }
 
-    template<typename Iterator>
+    int compare(const char* s) const;
-    String(Iterator first, Iterator last): cstr_(0), len_(0)
+    int compare(const String& str) const;
-    {
+
-        size_t len = (size_t)(last - first);
+    void swap(String& str);
-        char* str = allocate(len);
+    String substr(size_t pos = 0, size_t len = npos) const;
-        while (first != last)
+
-        {
+    size_t find(const char* s, size_t pos, size_t n) const;
-            *str++ = *first;
+    size_t find(char c, size_t pos = 0) const;
-            ++first;
+    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();
+        CV_XADD(((int*)str.cstr_)-1, 1);
-        if (str.cstr_) 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)
+inline String::String(const char* s) : cstr_(0), len_(0)
-    {
+{
-        deallocate();
+    if (!s) return;
-        if (!s) return *this;
+    size_t len = strlen(s);
-        size_t len = strlen(s);
+    memcpy(allocate(len), s, len);
-        memcpy(allocate(len), s, len);
+}
-        return *this;
+
-    }
+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();
+        *str++ = *first;
-        allocate(1)[0] = c;
+        ++first;
-        return *this;
     }
+}
 
-    size_t size() const { return len_; }
+inline String::~String()
-    size_t length() const { return len_; }
+{
+    deallocate();
+}
 
-    char operator[](size_t idx) const { return cstr_[idx]; }
+inline String& String::operator=(const String& str)
-    char operator[](int idx) const    { return cstr_[idx]; }
+{
+    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_; }
+inline String& String::operator=(const char* s)
-    const char* end() const { return len_ ? cstr_ + 1 : 0; }
+{
+    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)
+inline size_t String::length() const
-    {
+{
-        cv::swap(cstr_, str.cstr_);
+    return len_;
-        cv::swap(len_, str.len_);
+}
-    }
 
-    void clear() { deallocate(); }
+inline char String::operator[](size_t idx) const
+{
+    return cstr_[idx];
+}
 
-    int compare(const char* s) const
+inline char String::operator[](int idx) const
-    {
+{
-        if (cstr_ == s) return 0;
+    return cstr_[idx];
+}
 
-        return strcmp(c_str(), s);
+inline const char* String::begin() const
-    }
+{
+    return cstr_;
+}
 
-    int compare(const String& str) const
+inline const char* String::end() const
-    {
+{
-        if (cstr_ == str.cstr_) return 0;
+    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
+inline const char* String::c_str() const
-    {
+{
-        return String(*this, pos, len);
+    return cstr_ ? cstr_ : "";
-    }
+}
 
-    size_t find(const char* s, size_t pos, size_t n) const
+inline void String::swap(String& str)
-    {
+{
-        if (n == 0 || pos + n > len_) return npos;
+    cv::swap(cstr_, str.cstr_);
-        const char* lmax = cstr_ + len_ - n;
+    cv::swap(len_, str.len_);
-        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;
-    }
 
-    size_t find(char c, size_t pos = 0) const
+inline void String::clear()
-    {
+{
-        return find(&c, pos, 1);
+    deallocate();
-    }
+}
 
-    size_t find(const String& str, size_t pos = 0) const
+inline int String::compare(const char* s) const
-    {
+{
-        return find(str.c_str(), pos, str.len_);
+    if (cstr_ == s) return 0;
-    }
+    return strcmp(c_str(), s);
+}
 
-    size_t find(const char* s, size_t pos = 0) const
+inline int String::compare(const String& str) const
-    {
+{
-        if (pos >= len_ || !s[0]) return npos;
+    if (cstr_ == str.cstr_) return 0;
-        const char* lmax = cstr_ + len_;
+    return strcmp(c_str(), str.c_str());
-        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;
-    }
 
-    size_t rfind(const char* s, size_t pos, size_t n) const
+inline String String::substr(size_t pos, size_t len) const
-    {
+{
-        if (n > len_) return npos;
+    return String(*this, pos, len);
-        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;
-    }
 
-    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
+inline size_t String::find(char c, size_t pos) const
-    {
+{
-        return rfind(str.c_str(), pos, str.len_);
+    return find(&c, pos, 1);
-    }
+}
 
-    size_t rfind(const char* s, size_t pos = npos) const
+inline size_t String::find(const String& str, size_t pos) const
-    {
+{
-        return rfind(s, pos, strlen(s));
+    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;
+        size_t j = 0;
-        const char* lmax = cstr_ + len_;
+        while (s[j] && s[j] == i[j])
-        for (const char* i = cstr_ + pos; i < lmax; ++i)
+        {   if(i + j >= lmax) return npos;
-        {
+            ++j;
-            for (size_t j = 0; j < n; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
         }
-        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
+inline size_t String::rfind(char c, size_t pos) const
-    {
+{
-        return find_first_of(str.c_str(), pos, str.len_);
+    return rfind(&c, pos, 1);
-    }
+}
 
-    size_t find_first_of(const char* s, size_t pos = 0) const
+inline size_t String::rfind(const String& str, size_t pos) const
-    {
+{
-        if (pos >= len_ || !s[0]) return npos;
+    return rfind(str.c_str(), pos, str.len_);
-        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;
-    }
 
-    size_t find_last_of(const char* s, size_t pos, size_t n) const
+inline size_t String::rfind(const char* s, size_t pos) const
-    {
+{
-        if (pos >= len_) pos = len_ - 1;
+    return rfind(s, pos, strlen(s));
-        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;
-    }
 
-    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 (size_t j = 0; j < n; ++j)
-        for (const char* i = cstr_ + pos; i >= cstr_; --i)
+            if (s[j] == *i)
-        {
+                return (size_t)(i - cstr_);
-            for (size_t j = 0; s[j]; ++j)
-                if (s[j] == *i)
-                    return (size_t)(i - cstr_);
-        }
-        return npos;
     }
+    return npos;
+}
 
-    friend String operator+ (const String& lhs, const String& rhs);
+inline size_t String::find_last_of(char c, size_t pos) const
-    friend String operator+ (const String& lhs, const char*   rhs);
+{
-    friend String operator+ (const char*   lhs, const String& rhs);
+    return find_last_of(&c, pos, 1);
-    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
 
-    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:
+inline size_t String::find_last_of(const char* s, size_t pos) const
-    char*  cstr_;
+{
-    size_t len_;
+    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
+// ************************* cv::String non-member functions *************************
-    void deallocate();
-};
 
 inline String operator+ (const String& lhs, const String& rhs)
 {

modules/core/src/glob.cpp

@@ -111,11 +111,11 @@ static bool isDir(const cv::String& path, DIR* dir)
 
     return (attributes != INVALID_FILE_ATTRIBUTES) && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
 #else
+    (void)dir;
     struct stat stat_buf;
-    stat( path.c_str(), &stat_buf);
+    if (0 != stat( path.c_str(), &stat_buf))
+        return false;
     int is_dir = S_ISDIR( stat_buf.st_mode);
-    (void)dir;
-
     return is_dir != 0;
 #endif
 }