Skip to content

O
opencv
Commit 14bb4cbe authored by Andrey Kamaev's avatar Andrey Kamaev
Browse files
Options

Add cv::String class

parent ec15d6f3
Hide whitespace changes
Inline Side-by-side
Showing with 714 additions and 18 deletions
cmake/OpenCVModule.cmake
View file @ 14bb4cbe
......@@ -507,6 +507,8 @@ 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)
......
modules/core/include/opencv2/core.hpp
View file @ 14bb4cbe
......@@ -47,11 +47,12 @@
#define __OPENCV_CORE_HPP__
#include "opencv2/core/cvdef.h"
#include "opencv2/core/version.hpp"
#include "opencv2/core/types_c.h"
#include "opencv2/core/version.hpp"
#ifdef __cplusplus
#include "opencv2/core/cvstd.hpp"
#ifndef SKIP_INCLUDES
#include <limits.h>
......@@ -3939,7 +3940,10 @@ public:
//! returns the node content as double
operator double() const;
//! returns the node content as text string
operator String() const;
#ifndef OPENCV_NOSTL
operator std::string() const;
#endif
//! returns pointer to the underlying file node
CvFileNode* operator *();
......@@ -4419,9 +4423,11 @@ template<> struct ParamType<uchar>
} //namespace cv
#endif // __cplusplus
#include "opencv2/core/operations.hpp"
#include "opencv2/core/mat.hpp"
#include "opencv2/core/cvstd.inl.hpp"
#endif // __cplusplus
#endif /*__OPENCV_CORE_HPP__*/
modules/core/include/opencv2/core/cvstd.hpp 0 → 100644
View file @ 14bb4cbe
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#ifndef __OPENCV_CORE_CVSTD_HPP__
#define __OPENCV_CORE_CVSTD_HPP__
#include <cstddef>
#include <cstring>
#include "opencv2/core/cvdef.h"
#ifndef OPENCV_NOSTL
# include <string>
#endif
// import useful primitives from stl
#ifndef OPENCV_NOSTL_TRANSITIONAL
# include <algorithm>
# include <utility>
# include <cmath>
namespace cv
{
using std::min;
using std::max;
using std::abs;
using std::swap;
}
#else
namespace cv
{
template<typename T> inline T min(T a, T b) { return a < b ? a : b; }
template<typename T> inline T max(T a, T b) { return a > b ? a : b; }
template<typename T> inline T abs(T a) { return a < 0 ? -a : a; }
template<typename T> inline void swap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
template<> inline uchar abs(uchar a) { return a; }
template<> inline ushort abs(ushort a) { return a; }
template<> inline uint abs(uint a) { return a; }
template<> inline uint64 abs(uint64 a) { return a; }
}
#endif
namespace cv {
class CV_EXPORTS FileNode; //for string constructor from FileNode
class CV_EXPORTS String
{
public:
typedef char value_type;
typedef char& reference;
typedef const char& const_reference;
typedef char* pointer;
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) {}
String(const String& str) : cstr_(str.cstr_), len_(str.len_)
{
if (cstr_) CV_XADD(((int*)cstr_)-1, 1);
}
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);
}
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)
{
if (!n) return;
memcpy(allocate(n), s, n);
}
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)
{
size_t len = (size_t)(last - first);
memcpy(allocate(len), first, len);
}
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;
}
}
~String() { deallocate(); }
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)
{
deallocate();
if (!s) return *this;
size_t len = strlen(s);
memcpy(allocate(len), s, len);
return *this;
}
String& operator=(char c)
{
deallocate();
allocate(1)[0] = c;
return *this;
}
size_t size() const { return len_; }
size_t length() const { return len_; }
char operator[](size_t idx) const { return cstr_[idx]; }
char operator[](int idx) const { return cstr_[idx]; }
const char* begin() const { return cstr_; }
const char* end() const { return len_ ? cstr_ + 1 : 0; }
bool empty() const { return len_ == 0; }
const char* c_str() const { return cstr_ ? cstr_ : ""; }
void swap(String& str)
{
cv::swap(cstr_, str.cstr_);
cv::swap(len_, str.len_);
}
void clear() { deallocate(); }
int compare(const char* s) const
{
if (cstr_ == s) return 0;
return strcmp(c_str(), s);
}
int 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
{
return String(*this, pos, len);
}
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;
}
size_t find(char c, size_t pos = 0) const
{
return find(&c, pos, 1);
}
size_t find(const String& str, size_t pos = 0) const
{
return find(str.c_str(), pos, str.len_);
}
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;
}
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;
}
size_t rfind(char c, size_t pos = npos) const
{
return rfind(&c, pos, 1);
}
size_t rfind(const String& str, size_t pos = npos) const
{
return rfind(str.c_str(), pos, str.len_);
}
size_t rfind(const char* s, size_t pos = npos) const
{
return rfind(s, pos, strlen(s));
}
size_t 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)
{
for (size_t j = 0; j < n; ++j)
if (s[j] == *i)
return (size_t)(i - cstr_);
}
return npos;
}
size_t find_first_of(char c, size_t pos = 0) const
{
return find_first_of(&c, pos, 1);
}
size_t find_first_of(const String& str, size_t pos = 0) const
{
return find_first_of(str.c_str(), pos, str.len_);
}
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;
}
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;
}
size_t find_last_of(char c, size_t pos = npos) const
{
return find_last_of(&c, pos, 1);
}
size_t find_last_of(const String& str, size_t pos = npos) const
{
return find_last_of(str.c_str(), pos, str.len_);
}
size_t find_last_of(const char* s, size_t pos = npos) 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;
}
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
void deallocate();
};
inline String operator+ (const String& lhs, const String& rhs)
{
String s;
s.allocate(lhs.len_ + rhs.len_);
memcpy(s.cstr_, lhs.cstr_, lhs.len_);
memcpy(s.cstr_ + lhs.len_, rhs.cstr_, rhs.len_);
return s;
}
inline String operator+ (const String& lhs, const char* rhs)
{
String s;
size_t rhslen = strlen(rhs);
s.allocate(lhs.len_ + rhslen);
memcpy(s.cstr_, lhs.cstr_, lhs.len_);
memcpy(s.cstr_ + lhs.len_, rhs, rhslen);
return s;
}
inline String operator+ (const char* lhs, const String& rhs)
{
String s;
size_t lhslen = strlen(lhs);
s.allocate(lhslen + rhs.len_);
memcpy(s.cstr_, lhs, lhslen);
memcpy(s.cstr_ + lhslen, rhs.cstr_, rhs.len_);
return s;
}
inline String operator+ (const String& lhs, char rhs)
{
String s;
s.allocate(lhs.len_ + 1);
memcpy(s.cstr_, lhs.cstr_, lhs.len_);
s.cstr_[lhs.len_] = rhs;
return s;
}
inline String operator+ (char lhs, const String& rhs)
{
String s;
s.allocate(rhs.len_ + 1);
s.cstr_[0] = lhs;
memcpy(s.cstr_ + 1, rhs.cstr_, rhs.len_);
return s;
}
inline bool operator== (const String& lhs, const String& rhs) { return 0 == lhs.compare(rhs); }
inline bool operator== (const char* lhs, const String& rhs) { return 0 == rhs.compare(lhs); }
inline bool operator== (const String& lhs, const char* rhs) { return 0 == lhs.compare(rhs); }
inline bool operator!= (const String& lhs, const String& rhs) { return 0 != lhs.compare(rhs); }
inline bool operator!= (const char* lhs, const String& rhs) { return 0 != rhs.compare(lhs); }
inline bool operator!= (const String& lhs, const char* rhs) { return 0 != lhs.compare(rhs); }
inline bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
inline bool operator< (const char* lhs, const String& rhs) { return rhs.compare(lhs) > 0; }
inline bool operator< (const String& lhs, const char* rhs) { return lhs.compare(rhs) < 0; }
inline bool operator<= (const String& lhs, const String& rhs) { return lhs.compare(rhs) <= 0; }
inline bool operator<= (const char* lhs, const String& rhs) { return rhs.compare(lhs) >= 0; }
inline bool operator<= (const String& lhs, const char* rhs) { return lhs.compare(rhs) <= 0; }
inline bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
inline bool operator> (const char* lhs, const String& rhs) { return rhs.compare(lhs) < 0; }
inline bool operator> (const String& lhs, const char* rhs) { return lhs.compare(rhs) > 0; }
inline bool operator>= (const String& lhs, const String& rhs) { return lhs.compare(rhs) >= 0; }
inline bool operator>= (const char* lhs, const String& rhs) { return rhs.compare(lhs) <= 0; }
inline bool operator>= (const String& lhs, const char* rhs) { return lhs.compare(rhs) >= 0; }
} // cv
#ifndef OPENCV_NOSTL_TRANSITIONAL
namespace std
#else
namespace cv
#endif
{
template<> inline void swap<cv::String>(cv::String& a, cv::String& b) { a.swap(b); }
}
#endif //__OPENCV_CORE_CVSTD_HPP__
modules/core/include/opencv2/core/cvstd.inl.hpp 0 → 100644
View file @ 14bb4cbe
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#ifndef __OPENCV_CORE_CVSTDINL_HPP__
#define __OPENCV_CORE_CVSTDINL_HPP__
#ifndef OPENCV_NOSTL
# include <ostream>
#endif
namespace cv
{
#ifndef OPENCV_NOSTL
inline String::String(const std::string& str) : cstr_(0), len_(0)
{
if (!str.empty())
{
size_t len = str.size();
memcpy(allocate(len), str.c_str(), len);
}
}
inline String::String(const std::string& str, size_t pos, size_t len) : cstr_(0), len_(0)
{
size_t strlen = str.size();
pos = max(pos, strlen);
len = min(strlen - pos, len);
if (!len) return;
memcpy(allocate(len), str.c_str() + pos, len);
}
inline String& String::operator=(const std::string& str)
{
deallocate();
if (!str.empty())
{
size_t len = str.size();
memcpy(allocate(len), str.c_str(), len);
}
return *this;
}
inline String::operator std::string() const
{
return std::string(cstr_, len_);
}
inline String operator+ (const String& lhs, const std::string& rhs)
{
String s;
size_t rhslen = rhs.size();
s.allocate(lhs.len_ + rhslen);
memcpy(s.cstr_, lhs.cstr_, lhs.len_);
memcpy(s.cstr_ + lhs.len_, rhs.c_str(), rhslen);
return s;
}
inline String operator+ (const std::string& lhs, const String& rhs)
{
String s;
size_t lhslen = lhs.size();
s.allocate(lhslen + rhs.len_);
memcpy(s.cstr_, lhs.c_str(), lhslen);
memcpy(s.cstr_ + lhslen, rhs.cstr_, rhs.len_);
return s;
}
inline std::ostream& operator << (std::ostream& os, const String& str)
{
return os << str.c_str();
}
inline FileNode::operator std::string() const
{
cv::String value;
read(*this, value, value);
return value;
}
template<> inline void operator >> (const FileNode& n, std::string& value)
{
cv::String val;
read(n, val, val);
value = val;
}
#endif // OPENCV_NOSTL
} // cv
#endif // __OPENCV_CORE_CVSTDINL_HPP__
\ No newline at end of file
modules/core/include/opencv2/core/operations.hpp
View file @ 14bb4cbe
......@@ -2902,9 +2902,9 @@ static inline void read(const FileNode& node, double& value, double default_valu
CV_NODE_IS_REAL(node.node->tag) ? node.node->data.f : 1e300;
}
static inline void read(const FileNode& node, std::string& value, const std::string& default_value)
static inline void read(const FileNode& node, cv::String& value, const cv::String& default_value)
{
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? std::string(node.node->data.str.ptr) : std::string("");
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? cv::String(node.node->data.str.ptr) : cv::String();
}
CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
......@@ -2935,7 +2935,12 @@ inline FileNode::operator std::string() const
return value;
}
inline void FileNode::readRaw( const std::string& fmt, uchar* vec, size_t len ) const
inline String::String(const FileNode& fn): cstr_(0), len_(0)
{
read(fn, *this, *this);
}
inline void FileNode::readRaw( const cv::String& fmt, uchar* vec, size_t len ) const
{
begin().readRaw( fmt, vec, len );
}
......
modules/core/include/opencv2/core/utility.hpp
View file @ 14bb4cbe
......@@ -143,14 +143,14 @@ typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
*/
CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdata=0, void** prevUserdata=0);
CV_EXPORTS std::string format( const char* fmt, ... );
CV_EXPORTS std::string tempfile( const char* suffix CV_DEFAULT(0));
CV_EXPORTS void glob(std::string pattern, std::vector<std::string>& result, bool recursive = false);
CV_EXPORTS cv::String format( const char* fmt, ... );
CV_EXPORTS cv::String tempfile( const char* suffix CV_DEFAULT(0));
CV_EXPORTS void glob(cv::String pattern, std::vector<cv::String>& result, bool recursive = false);
CV_EXPORTS void setNumThreads(int nthreads);
CV_EXPORTS int getNumThreads();
CV_EXPORTS int getThreadNum();
CV_EXPORTS_W const std::string& getBuildInformation();
CV_EXPORTS_W const cv::String& getBuildInformation();
//! Returns the number of ticks.
......@@ -297,19 +297,19 @@ protected:
class CV_EXPORTS CommandLineParser
{
public:
CommandLineParser(int argc, const char* const argv[], const std::string& keys);
CommandLineParser(int argc, const char* const argv[], const cv::String& keys);
CommandLineParser(const CommandLineParser& parser);
CommandLineParser& operator = (const CommandLineParser& parser);
std::string getPathToApplication() const;
cv::String getPathToApplication() const;
template <typename T>
T get(const std::string& name, bool space_delete = true) const
{
T get(const cv::String& name, bool space_delete = true) const
{
T val = T();
getByName(name, space_delete, ParamType<T>::type, (void*)&val);
return val;
}
}
template <typename T>
T get(int index, bool space_delete = true) const
......@@ -319,17 +319,17 @@ class CV_EXPORTS CommandLineParser
return val;
}
bool has(const std::string& name) const;
bool has(const cv::String& name) const;
bool check() const;
void about(const std::string& message);
void about(const cv::String& message);
void printMessage() const;
void printErrors() const;
protected:
void getByName(const std::string& name, bool space_delete, int type, void* dst) const;
void getByName(const cv::String& name, bool space_delete, int type, void* dst) const;
void getByIndex(int index, bool space_delete, int type, void* dst) const;
struct Impl;
......@@ -454,6 +454,17 @@ static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMod
return cvarrToMat(arr, copyData, true, coiMode);
}
#ifndef OPENCV_NOSTL
template<> inline std::string CommandLineParser::get<std::string>(int index, bool space_delete) const
{
return get<String>(index, space_delete);
}
template<> inline std::string CommandLineParser::get<std::string>(const cv::String& name, bool space_delete) const
{
return get<String>(name, space_delete);
}
#endif // OPENCV_NOSTL
} //namespace cv
#endif //__OPENCV_CORE_UTILITY_H__
modules/core/src/stl.cpp 0 → 100644
View file @ 14bb4cbe
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"
char* cv::String::allocate(size_t len)
{
size_t totalsize = alignSize(len + 1, (int)sizeof(int));
int* data = (int*)cv::fastMalloc(totalsize + sizeof(int));
data[0] = 1;
cstr_ = (char*)(data + 1);
len_ = len;
cstr_[len] = 0;
return cstr_;
}
void cv::String::deallocate()
{
int* data = (int*)cstr_;
len_ = 0;
cstr_ = 0;
if(data && 1 == CV_XADD(data-1, -1))
{
cv::fastFree(data-1);
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment