x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
SString.h - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\scintilla\include\SString.h
旋转
特效
属性
历史版本
// SciTE - Scintilla based Text Editor /** @file SString.h ** A simple string class. **/ // Copyright 1998-2004 by Neil Hodgson
// The License.txt file describes the conditions under which this software may be distributed. #ifndef SSTRING_H #define SSTRING_H // These functions are implemented because each platform calls them something different. int CompareCaseInsensitive(const char *a, const char *b); int CompareNCaseInsensitive(const char *a, const char *b, size_t len); bool EqualCaseInsensitive(const char *a, const char *b); #ifdef SCI_NAMESPACE namespace Scintilla { #endif // Define another string class. // While it would be 'better' to use std::string, that doubles the executable size. // An SString may contain embedded nul characters. /** * Base class from which the two other classes (SBuffer & SString) * are derived. */ class SContainer { public: /** Type of string lengths (sizes) and positions (indexes). */ typedef size_t lenpos_t; /** Out of bounds value indicating that the string argument should be measured. */ enum { measure_length=0xffffffffU}; protected: char *s; ///< The C string lenpos_t sSize; ///< The size of the buffer, less 1: ie. the maximum size of the string SContainer() : s(0), sSize(0) {} ~SContainer() { delete []s; // Suppose it was allocated using StringAllocate s = 0; sSize = 0; } /** Size of buffer. */ lenpos_t size() const { if (s) { return sSize; } else { return 0; } } public: /** * Allocate uninitialized memory big enough to fit a string of the given length. * @return the pointer to the new string */ static char *StringAllocate(lenpos_t len); /** * Duplicate a buffer/C string. * Allocate memory of the given size, or big enough to fit the string if length isn't given; * then copy the given string in the allocated memory. * @return the pointer to the new string */ static char *StringAllocate( const char *s, ///< The string to duplicate lenpos_t len=measure_length); ///< The length of memory to allocate. Optional. }; /** * @brief A string buffer class. * * Main use is to ask an API the length of a string it can provide, * then to allocate a buffer of the given size, and to provide this buffer * to the API to put the string. * This class is intended to be shortlived, to be transformed as SString * as soon as it holds the string, so it has little members. * Note: we assume the buffer is filled by the API. If the length can be shorter, * we should set sLen to strlen(sb.ptr()) in related SString constructor and assignment. */ class SBuffer : protected SContainer { public: SBuffer(lenpos_t len) { s = StringAllocate(len); if (s) { *s = '\0'; sSize = len; } else { sSize = 0; } } private: /// Copy constructor // Here only to be on the safe size, user should avoid returning SBuffer values. SBuffer(const SBuffer &source) : SContainer() { s = StringAllocate(source.s, source.sSize); sSize = (s) ? source.sSize : 0; } /// Default assignment operator // Same here, shouldn't be used SBuffer &operator=(const SBuffer &source) { if (this != &source) { delete []s; s = StringAllocate(source.s, source.sSize); sSize = (s) ? source.sSize : 0; } return *this; } public: /** Provide direct read/write access to buffer. */ char *ptr() { return s; } /** Ownership of the buffer have been taken, so release it. */ void reset() { s = 0; sSize = 0; } /** Size of buffer. */ lenpos_t size() const { return SContainer::size(); } }; /** * @brief A simple string class. * * Hold the length of the string for quick operations, * can have a buffer bigger than the string to avoid too many memory allocations and copies. * May have embedded zeroes as a result of @a substitute, but relies too heavily on C string * functions to allow reliable manipulations of these strings, other than simple appends, etc. */ class SString : protected SContainer { lenpos_t sLen; ///< The size of the string in s lenpos_t sizeGrowth; ///< Minimum growth size when appending strings enum { sizeGrowthDefault = 64 }; bool grow(lenpos_t lenNew); SString &assign(const char *sOther, lenpos_t sSize_=measure_length); public: SString() : sLen(0), sizeGrowth(sizeGrowthDefault) {} SString(const SString &source) : SContainer(), sizeGrowth(sizeGrowthDefault) { s = StringAllocate(source.s, source.sLen); sSize = sLen = (s) ? source.sLen : 0; } SString(const char *s_) : sizeGrowth(sizeGrowthDefault) { s = StringAllocate(s_); sSize = sLen = (s) ? strlen(s) : 0; } SString(SBuffer &buf) : sizeGrowth(sizeGrowthDefault) { s = buf.ptr(); sSize = sLen = buf.size(); // Consumes the given buffer! buf.reset(); } SString(const char *s_, lenpos_t first, lenpos_t last) : sizeGrowth(sizeGrowthDefault) { // note: expects the "last" argument to point one beyond the range end (a la STL iterators) s = StringAllocate(s_ + first, last - first); sSize = sLen = (s) ? last - first : 0; } SString(int i); SString(double d, int precision); ~SString() { sLen = 0; } void clear() { if (s) { *s = '\0'; } sLen = 0; } /** Size of buffer. */ lenpos_t size() const { return SContainer::size(); } /** Size of string in buffer. */ lenpos_t length() const { return sLen; } /** Read access to a character of the string. */ char operator[](lenpos_t i) const { return (s && i < sSize) ? s[i] : '\0'; } SString &operator=(const char *source) { return assign(source); } SString &operator=(const SString &source) { if (this != &source) { assign(source.s, source.sLen); } return *this; } bool operator==(const SString &sOther) const; bool operator!=(const SString &sOther) const { return !operator==(sOther); } bool operator==(const char *sOther) const; bool operator!=(const char *sOther) const { return !operator==(sOther); } bool contains(char ch) const { return (s && *s) ? strchr(s, ch) != 0 : false; } void setsizegrowth(lenpos_t sizeGrowth_) { sizeGrowth = sizeGrowth_; } const char *c_str() const { return s ? s : ""; } /** Give ownership of buffer to caller which must use delete[] to free buffer. */ char *detach() { char *sRet = s; s = 0; sSize = 0; sLen = 0; return sRet; } SString substr(lenpos_t subPos, lenpos_t subLen=measure_length) const; SString &lowercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length); SString &uppercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length); SString &append(const char *sOther, lenpos_t sLenOther=measure_length, char sep = '\0'); SString &operator+=(const char *sOther) { return append(sOther, static_cast
(measure_length)); } SString &operator+=(const SString &sOther) { return append(sOther.s, sOther.sLen); } SString &operator+=(char ch) { return append(&ch, 1); } SString &appendwithseparator(const char *sOther, char sep) { return append(sOther, strlen(sOther), sep); } SString &insert(lenpos_t pos, const char *sOther, lenpos_t sLenOther=measure_length); /** * Remove @a len characters from the @a pos position, included. * Characters at pos + len and beyond replace characters at pos. * If @a len is 0, or greater than the length of the string * starting at @a pos, the string is just truncated at @a pos. */ void remove(lenpos_t pos, lenpos_t len); SString &change(lenpos_t pos, char ch) { if (pos < sLen) { // character changed must be in string bounds *(s + pos) = ch; } return *this; } /** Read an integral numeric value from the string. */ int value() const { return s ? atoi(s) : 0; } bool startswith(const char *prefix); bool endswith(const char *suffix); int search(const char *sFind, lenpos_t start=0) const; bool contains(const char *sFind) const { return search(sFind) >= 0; } int substitute(char chFind, char chReplace); int substitute(const char *sFind, const char *sReplace); int remove(const char *sFind) { return substitute(sFind, ""); } }; /** * Duplicate a C string. * Allocate memory of the given size, or big enough to fit the string if length isn't given; * then copy the given string in the allocated memory. * @return the pointer to the new string */ inline char *StringDup( const char *s, ///< The string to duplicate SContainer::lenpos_t len=SContainer::measure_length) ///< The length of memory to allocate. Optional. { return SContainer::StringAllocate(s, len); } #ifdef SCI_NAMESPACE } #endif #endif
SString.h
网页地址
文件地址
上一页
11/12
下一页
下载
( 8 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.