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__
+#  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,21 +100,104 @@ 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;
+
+    char operator[](size_t idx) const;
+    char operator[](int idx) const;
+
+    const char* begin() const;
+    const char* end() const;
+
+    const char* c_str() const;
+
+    bool empty() const;
+    void clear();
+
+    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();
+};
+
+// **************************** cv::String implementation ****************************
+
+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;
@@ -122,35 +209,35 @@ public:
         return;
     }
     memcpy(allocate(len), str.cstr_ + pos, len);
-    }
+}
 
-    String(const char* s): cstr_(0), len_(0)
+inline String::String(const char* s) : cstr_(0), len_(0)
-    {
+{
     if (!s) return;
     size_t len = strlen(s);
     memcpy(allocate(len), s, len);
-    }
+}
 
-    String(const char* s, size_t n): cstr_(0), len_(0)
+inline String::String(const char* s, size_t n) : cstr_(0), len_(0)
-    {
+{
     if (!n) return;
     memcpy(allocate(n), s, n);
-    }
+}
 
-    String(size_t n, char c): cstr_(0), len_(0)
+inline String::String(size_t n, char c) : cstr_(0), len_(0)
-    {
+{
     memset(allocate(n), c, n);
-    }
+}
 
-    String(const char* first, const char* last): cstr_(0), len_(0)
+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);
-    }
+}
 
-    template<typename Iterator>
+template<typename Iterator>
-    String(Iterator first, Iterator last): cstr_(0), len_(0)
+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)
@@ -158,77 +245,108 @@ public:
         *str++ = *first;
         ++first;
     }
-    }
+}
 
-    ~String() { deallocate(); }
+inline String::~String()
+{
+    deallocate();
+}
 
-    String& operator=(const String& str)
+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;
-    }
+}
 
-    String& operator=(const char* s)
+inline String& String::operator=(const char* s)
-    {
+{
     deallocate();
     if (!s) return *this;
     size_t len = strlen(s);
     memcpy(allocate(len), s, len);
     return *this;
-    }
+}
 
-    String& operator=(char c)
+inline String& String::operator=(char c)
-    {
+{
     deallocate();
     allocate(1)[0] = c;
     return *this;
-    }
+}
 
-    size_t size() const { return len_; }
+inline size_t String::size() const
-    size_t length() const { return len_; }
+{
+    return len_;
+}
 
-    char operator[](size_t idx) const { return cstr_[idx]; }
+inline size_t String::length() const
-    char operator[](int idx) const    { return cstr_[idx]; }
+{
+    return len_;
+}
 
-    const char* begin() const { return cstr_; }
+inline char String::operator[](size_t idx) const
-    const char* end() const { return len_ ? cstr_ + 1 : 0; }
+{
+    return cstr_[idx];
+}
 
-    bool empty() const { return len_ == 0; }
+inline char String::operator[](int idx) const
+{
+    return cstr_[idx];
+}
 
-    const char* c_str() const { return cstr_ ? cstr_ : ""; }
+inline const char* String::begin() const
+{
+    return cstr_;
+}
 
-    void swap(String& str)
+inline const char* String::end() const
-    {
+{
+    return len_ ? cstr_ + 1 : 0;
+}
+
+inline bool String::empty() const
+{
+    return len_ == 0;
+}
+
+inline const char* String::c_str() const
+{
+    return cstr_ ? cstr_ : "";
+}
+
+inline void String::swap(String& str)
+{
     cv::swap(cstr_, str.cstr_);
     cv::swap(len_, str.len_);
-    }
+}
 
-    void clear() { deallocate(); }
+inline void String::clear()
+{
+    deallocate();
+}
 
-    int compare(const char* s) const
+inline int String::compare(const char* s) const
-    {
+{
     if (cstr_ == s) return 0;
-
     return strcmp(c_str(), s);
-    }
+}
 
-    int compare(const String& str) const
+inline int String::compare(const String& str) const
-    {
+{
     if (cstr_ == str.cstr_) return 0;
-
     return strcmp(c_str(), str.c_str());
-    }
+}
 
-    String substr(size_t pos = 0, size_t len = npos) const
+inline String String::substr(size_t pos, size_t len) const
-    {
+{
     return String(*this, pos, len);
-    }
+}
 
-    size_t find(const char* s, size_t pos, size_t n) 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)
@@ -238,20 +356,20 @@ public:
         if (j == n) return (size_t)(i - cstr_);
     }
     return npos;
-    }
+}
 
-    size_t find(char c, size_t pos = 0) const
+inline size_t String::find(char c, size_t pos) const
-    {
+{
     return find(&c, pos, 1);
-    }
+}
 
-    size_t find(const String& str, size_t pos = 0) const
+inline size_t String::find(const String& str, size_t pos) const
-    {
+{
     return find(str.c_str(), pos, str.len_);
-    }
+}
 
-    size_t find(const char* s, size_t pos = 0) 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)
@@ -264,10 +382,10 @@ public:
         if (!s[j]) return (size_t)(i - cstr_);
     }
     return npos;
-    }
+}
 
-    size_t rfind(const char* s, size_t pos, size_t n) 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)
@@ -277,25 +395,25 @@ public:
         if (j == n) return (size_t)(i - cstr_);
     }
     return npos;
-    }
+}
 
-    size_t rfind(char c, size_t pos = npos) const
+inline size_t String::rfind(char c, size_t pos) const
-    {
+{
     return rfind(&c, pos, 1);
-    }
+}
 
-    size_t rfind(const String& str, size_t pos = npos) const
+inline size_t String::rfind(const String& str, size_t pos) const
-    {
+{
     return rfind(str.c_str(), pos, str.len_);
-    }
+}
 
-    size_t rfind(const char* s, size_t pos = npos) const
+inline size_t String::rfind(const char* s, size_t pos) const
-    {
+{
     return rfind(s, pos, strlen(s));
-    }
+}
 
-    size_t find_first_of(const char* s, size_t pos, size_t n) 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)
@@ -305,20 +423,20 @@ public:
                 return (size_t)(i - cstr_);
     }
     return npos;
-    }
+}
 
-    size_t find_first_of(char c, size_t pos = 0) const
+inline size_t String::find_first_of(char c, size_t pos) const
-    {
+{
     return find_first_of(&c, pos, 1);
-    }
+}
 
-    size_t find_first_of(const String& str, size_t pos = 0) 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_);
-    }
+}
 
-    size_t find_first_of(const char* s, size_t pos = 0) const
+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)
@@ -328,10 +446,10 @@ public:
                 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::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)
     {
@@ -340,20 +458,20 @@ public:
                 return (size_t)(i - cstr_);
     }
     return npos;
-    }
+}
 
-    size_t find_last_of(char c, size_t pos = npos) const
+inline size_t String::find_last_of(char c, size_t pos) const
-    {
+{
     return find_last_of(&c, pos, 1);
-    }
+}
 
-    size_t find_last_of(const String& str, size_t pos = npos) const
+inline size_t String::find_last_of(const String& str, size_t pos) const
-    {
+{
     return find_last_of(str.c_str(), pos, str.len_);
-    }
+}
 
-    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) const
-    {
+{
     if (pos >= len_) pos = len_ - 1;
     for (const char* i = cstr_ + pos; i >= cstr_; --i)
     {
@@ -362,33 +480,9 @@ public:
                 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
-
-    explicit String(const FileNode& fn);
-
-private:
-    char*  cstr_;
-    size_t len_;
 
-    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
 }