#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
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)
{
projects / profile / ivi / opencv.git / commitdiff