OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Mark the parts of plString which are noexcept-safe as such

Michael Hansen 10 years ago
parent
dc4d428eb2
commit
0332ce0f5a
2 changed files with 67 additions and 67 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 14
      Sources/Plasma/CoreLib/plString.cpp
  2. 120
      Sources/Plasma/CoreLib/plString.h

14
Sources/Plasma/CoreLib/plString.cpp
Unescape View File

@ -489,23 +489,23 @@ plUnicodeBuffer plString::GetUnicodeArray() const
return result; return result;
} }
int plString::ToInt(int base) const int plString::ToInt(int base) const HS_NOEXCEPT
{ {
return static_cast<int>(strtol(c_str(), nullptr, base)); return static_cast<int>(strtol(c_str(), nullptr, base));
} }
unsigned int plString::ToUInt(int base) const unsigned int plString::ToUInt(int base) const HS_NOEXCEPT
{ {
return static_cast<unsigned int>(strtoul(c_str(), nullptr, base)); return static_cast<unsigned int>(strtoul(c_str(), nullptr, base));
} }
float plString::ToFloat() const float plString::ToFloat() const HS_NOEXCEPT
{ {
// strtof is C99, which MS doesn't support... // strtof is C99, which MS doesn't support...
return (float)strtod(c_str(), nullptr); return (float)strtod(c_str(), nullptr);
} }
double plString::ToDouble() const double plString::ToDouble() const HS_NOEXCEPT
{ {
return strtod(c_str(), nullptr); return strtod(c_str(), nullptr);
} }
@ -550,7 +550,7 @@ plString plString::IFormat(const char *fmt, va_list vptr)
return plString::FromUtf8(buffer, chars); return plString::FromUtf8(buffer, chars);
} }
ssize_t plString::Find(char ch, CaseSensitivity sense) const ssize_t plString::Find(char ch, CaseSensitivity sense) const HS_NOEXCEPT
{ {
if (sense == kCaseSensitive) { if (sense == kCaseSensitive) {
const char *cp = strchr(c_str(), ch); const char *cp = strchr(c_str(), ch);
@ -566,7 +566,7 @@ ssize_t plString::Find(char ch, CaseSensitivity sense) const
} }
} }
ssize_t plString::FindLast(char ch, CaseSensitivity sense) const ssize_t plString::FindLast(char ch, CaseSensitivity sense) const HS_NOEXCEPT
{ {
if (IsEmpty()) if (IsEmpty())
return -1; return -1;
@ -586,7 +586,7 @@ ssize_t plString::FindLast(char ch, CaseSensitivity sense) const
} }
} }
ssize_t plString::Find(const char *str, CaseSensitivity sense) const ssize_t plString::Find(const char *str, CaseSensitivity sense) const HS_NOEXCEPT
{ {
if (!str || !str[0]) if (!str || !str[0])
return -1; return -1;

120
Sources/Plasma/CoreLib/plString.h
Unescape View File

@ -95,11 +95,11 @@ private:
unsigned int fRefs; unsigned int fRefs;
const _Ch *fStringData; const _Ch *fStringData;
StringRef(const _Ch *data) StringRef(const _Ch *data) HS_NOEXCEPT
: fRefs(1), fStringData(data) { } : fRefs(1), fStringData(data) { }
inline void AddRef() { ++fRefs; } inline void AddRef() HS_NOEXCEPT { ++fRefs; }
inline void DecRef() inline void DecRef() HS_NOEXCEPT
{ {
if (--fRefs == 0) { if (--fRefs == 0) {
delete [] fStringData; delete [] fStringData;
@ -114,14 +114,14 @@ private:
}; };
size_t fSize; size_t fSize;
bool IHaveACow() const { return fSize >= SSO_CHARS; } bool IHaveACow() const HS_NOEXCEPT { return fSize >= SSO_CHARS; }
public: public:
/** Construct an empty string buffer. */ /** Construct an empty string buffer. */
plStringBuffer() : fSize(0) { memset(fShort, 0, sizeof(fShort)); } plStringBuffer() HS_NOEXCEPT : fSize(0) { memset(fShort, 0, sizeof(fShort)); }
/** Copy constructor - adds a reference to the copied buffer */ /** Copy constructor - adds a reference to the copied buffer */
plStringBuffer(const plStringBuffer<_Ch> &copy) : fSize(copy.fSize) plStringBuffer(const plStringBuffer<_Ch> &copy) HS_NOEXCEPT : fSize(copy.fSize)
{ {
memcpy(fShort, copy.fShort, sizeof(fShort)); memcpy(fShort, copy.fShort, sizeof(fShort));
if (IHaveACow()) if (IHaveACow())
@ -129,7 +129,7 @@ public:
} }
/** Move constructor */ /** Move constructor */
plStringBuffer(plStringBuffer<_Ch> &&move) : fSize(move.fSize) plStringBuffer(plStringBuffer<_Ch> &&move) HS_NOEXCEPT : fSize(move.fSize)
{ {
memcpy(fShort, move.fShort, sizeof(fShort)); memcpy(fShort, move.fShort, sizeof(fShort));
move.fSize = 0; move.fSize = 0;
@ -154,7 +154,7 @@ public:
/** Destructor. The ref-counted data will only be freed if no other /** Destructor. The ref-counted data will only be freed if no other
* string buffers still reference it. * string buffers still reference it.
*/ */
~plStringBuffer<_Ch>() ~plStringBuffer<_Ch>() HS_NOEXCEPT
{ {
if (IHaveACow()) if (IHaveACow())
fData->DecRef(); fData->DecRef();
@ -163,7 +163,7 @@ public:
/** Assignment operator. Changes the reference to point to the /** Assignment operator. Changes the reference to point to the
* buffer in \a copy. * buffer in \a copy.
*/ */
plStringBuffer<_Ch> &operator=(const plStringBuffer<_Ch> &copy) plStringBuffer<_Ch> &operator=(const plStringBuffer<_Ch> &copy) HS_NOEXCEPT
{ {
if (copy.IHaveACow()) if (copy.IHaveACow())
copy.fData->AddRef(); copy.fData->AddRef();
@ -176,7 +176,7 @@ public:
} }
/** Move assignment operator */ /** Move assignment operator */
plStringBuffer<_Ch> &operator=(plStringBuffer<_Ch> &&move) plStringBuffer<_Ch> &operator=(plStringBuffer<_Ch> &&move) HS_NOEXCEPT
{ {
if (IHaveACow()) if (IHaveACow())
fData->DecRef(); fData->DecRef();
@ -188,17 +188,17 @@ public:
} }
/** Returns a pointer to the referenced string buffer. */ /** Returns a pointer to the referenced string buffer. */
const _Ch *GetData() const { return IHaveACow() ? fData->fStringData : fShort; } const _Ch *GetData() const HS_NOEXCEPT { return IHaveACow() ? fData->fStringData : fShort; }
/** Returns the number of characters (not including the '\0') in the /** Returns the number of characters (not including the '\0') in the
* referenced string buffer. * referenced string buffer.
*/ */
size_t GetSize() const { return fSize; } size_t GetSize() const HS_NOEXCEPT { return fSize; }
/** Cast operator. This is a shortcut for not needing to call GetData on /** Cast operator. This is a shortcut for not needing to call GetData on
* buffer objects passed to methods or objects expecting a C-style string. * buffer objects passed to methods or objects expecting a C-style string.
*/ */
operator const _Ch *() const { return GetData(); } operator const _Ch *() const HS_NOEXCEPT { return GetData(); }
/** Create a writable buffer for \a size characters. /** Create a writable buffer for \a size characters.
* From Haxxia with love! This will release the current string buffer * From Haxxia with love! This will release the current string buffer
@ -266,7 +266,7 @@ public:
public: public:
/** Construct a valid, empty string. */ /** Construct a valid, empty string. */
plString() { } plString() HS_NOEXCEPT { }
/** Construct a string from a C-style string. /** Construct a string from a C-style string.
* \note This constructor expects the input to be UTF-8 encoded. For * \note This constructor expects the input to be UTF-8 encoded. For
@ -286,19 +286,19 @@ public:
plString(char (&literal)[_Sz]) { IConvertFromUtf8(literal, STRLEN_AUTO); } plString(char (&literal)[_Sz]) { IConvertFromUtf8(literal, STRLEN_AUTO); }
/** Copy constructor. */ /** Copy constructor. */
plString(const plString &copy) : fUtf8Buffer(copy.fUtf8Buffer) { } plString(const plString &copy) HS_NOEXCEPT : fUtf8Buffer(copy.fUtf8Buffer) { }
/** Move constructor. */ /** Move constructor. */
plString(plString &&move) : fUtf8Buffer(std::move(move.fUtf8Buffer)) { } plString(plString &&move) HS_NOEXCEPT : fUtf8Buffer(std::move(move.fUtf8Buffer)) { }
/** Copy constructor from plStringBuffer<char>. /** Copy constructor from plStringBuffer<char>.
* \note This constructor expects the input to be UTF-8 encoded. For * \note This constructor expects the input to be UTF-8 encoded. For
* conversion from ISO-8859-1 8-bit data, use FromIso8859_1(). * conversion from ISO-8859-1 8-bit data, use FromIso8859_1().
*/ */
plString(const plStringBuffer<char> &init) { operator=(init); } plString(const plStringBuffer<char> &init) HS_NOEXCEPT { operator=(init); }
/** Move constructor from plStringBuffer<char>. */ /** Move constructor from plStringBuffer<char>. */
plString(plStringBuffer<char> &&init) { operator=(std::move(init)); } plString(plStringBuffer<char> &&init) HS_NOEXCEPT { operator=(std::move(init)); }
/** Construct a string from expanded Unicode data. */ /** Construct a string from expanded Unicode data. */
plString(const plUnicodeBuffer &init) { IConvertFromUtf32(init.GetData(), init.GetSize()); } plString(const plUnicodeBuffer &init) { IConvertFromUtf32(init.GetData(), init.GetSize()); }
@ -315,10 +315,10 @@ public:
plString &operator=(char (&literal)[_Sz]) { IConvertFromUtf8(literal, STRLEN_AUTO); return *this; } plString &operator=(char (&literal)[_Sz]) { IConvertFromUtf8(literal, STRLEN_AUTO); return *this; }
/** Assignment operator. Same as plString(const plString &). */ /** Assignment operator. Same as plString(const plString &). */
plString &operator=(const plString &copy) { fUtf8Buffer = copy.fUtf8Buffer; return *this; } plString &operator=(const plString &copy) HS_NOEXCEPT { fUtf8Buffer = copy.fUtf8Buffer; return *this; }
/** Assignment operator. Same as plString(plString &&). */ /** Assignment operator. Same as plString(plString &&). */
plString &operator=(plString &&move) { fUtf8Buffer = std::move(move.fUtf8Buffer); return *this; } plString &operator=(plString &&move) HS_NOEXCEPT { fUtf8Buffer = std::move(move.fUtf8Buffer); return *this; }
/** Assignment operator. Same as plString(const plStringBuffer<char> &). */ /** Assignment operator. Same as plString(const plStringBuffer<char> &). */
plString &operator=(const plStringBuffer<char> &init); plString &operator=(const plStringBuffer<char> &init);
@ -384,17 +384,17 @@ public:
* expecting C-style string pointers. If this string is empty, returns * expecting C-style string pointers. If this string is empty, returns
* \a substitute instead. * \a substitute instead.
*/ */
const char *c_str(const char *substitute = "") const const char *c_str(const char *substitute = "") const HS_NOEXCEPT
{ return IsEmpty() ? substitute : fUtf8Buffer.GetData(); } { return IsEmpty() ? substitute : fUtf8Buffer.GetData(); }
/** Return the byte at position \a position. Note that this may be in /** Return the byte at position \a position. Note that this may be in
* the middle of a UTF-8 sequence -- if you want an actual Unicode * the middle of a UTF-8 sequence -- if you want an actual Unicode
* character, use the buffer returned from GetUnicodeArray() instead. * character, use the buffer returned from GetUnicodeArray() instead.
*/ */
char CharAt(size_t position) const { return c_str()[position]; } char CharAt(size_t position) const HS_NOEXCEPT { return c_str()[position]; }
/** Returns the internal UTF-8 data buffer object. */ /** Returns the internal UTF-8 data buffer object. */
plStringBuffer<char> ToUtf8() const { return fUtf8Buffer; } plStringBuffer<char> ToUtf8() const HS_NOEXCEPT { return fUtf8Buffer; }
/** Convert this string's data to a UTF-16 string buffer. */ /** Convert this string's data to a UTF-16 string buffer. */
plStringBuffer<uint16_t> ToUtf16() const; plStringBuffer<uint16_t> ToUtf16() const;
@ -421,10 +421,10 @@ public:
/** Returns the size in number of bytes (excluding the null-terminator) of /** Returns the size in number of bytes (excluding the null-terminator) of
* this string. * this string.
*/ */
size_t GetSize() const { return fUtf8Buffer.GetSize(); } size_t GetSize() const HS_NOEXCEPT { return fUtf8Buffer.GetSize(); }
/** Returns \c true if this string is empty (""). */ /** Returns \c true if this string is empty (""). */
bool IsEmpty() const { return fUtf8Buffer.GetSize() == 0; } bool IsEmpty() const HS_NOEXCEPT { return fUtf8Buffer.GetSize() == 0; }
/** Returns \c true if this string is "null". Currently, this is just /** Returns \c true if this string is "null". Currently, this is just
* a synonym for IsEmpty(), as plString makes no distinction between * a synonym for IsEmpty(), as plString makes no distinction between
@ -432,27 +432,27 @@ public:
* \todo Evaluate whether Plasma actually needs to distinguish between * \todo Evaluate whether Plasma actually needs to distinguish between
* empty and NULL strings. Ideally, only IsEmpty should be required. * empty and NULL strings. Ideally, only IsEmpty should be required.
*/ */
bool IsNull() const { return IsEmpty(); } bool IsNull() const HS_NOEXCEPT { return IsEmpty(); }
/** Convert the string data to an integer in base \a base. /** Convert the string data to an integer in base \a base.
* If base is set to 0, this function behaves like strtol, which checks * If base is set to 0, this function behaves like strtol, which checks
* for hex or octal prefixes (e.g. 0777 or 0x1234), and assumes base 10 * for hex or octal prefixes (e.g. 0777 or 0x1234), and assumes base 10
* if none are found. * if none are found.
*/ */
int ToInt(int base = 0) const; int ToInt(int base = 0) const HS_NOEXCEPT;
/** Convert the string to an unsigned integer in base \a base. /** Convert the string to an unsigned integer in base \a base.
* If base is set to 0, this function behaves like strtoul, which checks * If base is set to 0, this function behaves like strtoul, which checks
* for hex or octal prefixes (e.g. 0777 or 0x1234), and assumes base 10 * for hex or octal prefixes (e.g. 0777 or 0x1234), and assumes base 10
* if none are found. * if none are found.
*/ */
unsigned int ToUInt(int base = 0) const; unsigned int ToUInt(int base = 0) const HS_NOEXCEPT;
/** Convert the string to a floating point value. */ /** Convert the string to a floating point value. */
float ToFloat() const; float ToFloat() const HS_NOEXCEPT;
/** Convert the string to a double precision floating point value. */ /** Convert the string to a double precision floating point value. */
double ToDouble() const; double ToDouble() const HS_NOEXCEPT;
/** Construct a plString using a printf-like format string. /** Construct a plString using a printf-like format string.
* This function should be called inside of other vararg functions, * This function should be called inside of other vararg functions,
@ -470,7 +470,7 @@ public:
* \li \p \<0 - this string is lexicographically less than \a str * \li \p \<0 - this string is lexicographically less than \a str
* \li \p \>0 - this string is lexicographically greater than \a str * \li \p \>0 - this string is lexicographically greater than \a str
*/ */
int Compare(const plString &str, CaseSensitivity sense = kCaseSensitive) const int Compare(const plString &str, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT
{ {
return (sense == kCaseSensitive) ? strcmp(c_str(), str.c_str()) return (sense == kCaseSensitive) ? strcmp(c_str(), str.c_str())
: stricmp(c_str(), str.c_str()); : stricmp(c_str(), str.c_str());
@ -482,7 +482,7 @@ public:
* \li \p \<0 - this string is lexicographically less than \a str * \li \p \<0 - this string is lexicographically less than \a str
* \li \p \>0 - this string is lexicographically greater than \a str * \li \p \>0 - this string is lexicographically greater than \a str
*/ */
int Compare(const char *str, CaseSensitivity sense = kCaseSensitive) const int Compare(const char *str, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT
{ {
return (sense == kCaseSensitive) ? strcmp(c_str(), str ? str : "") return (sense == kCaseSensitive) ? strcmp(c_str(), str ? str : "")
: stricmp(c_str(), str ? str : ""); : stricmp(c_str(), str ? str : "");
@ -492,7 +492,7 @@ public:
* string with \a str. * string with \a str.
* \sa Compare(const plString &, CaseSensitivity) const * \sa Compare(const plString &, CaseSensitivity) const
*/ */
int CompareN(const plString &str, size_t count, CaseSensitivity sense = kCaseSensitive) const int CompareN(const plString &str, size_t count, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT
{ {
return (sense == kCaseSensitive) ? strncmp(c_str(), str.c_str(), count) return (sense == kCaseSensitive) ? strncmp(c_str(), str.c_str(), count)
: strnicmp(c_str(), str.c_str(), count); : strnicmp(c_str(), str.c_str(), count);
@ -502,58 +502,58 @@ public:
* string with \a str. * string with \a str.
* \sa Compare(const char *, CaseSensitivity) const * \sa Compare(const char *, CaseSensitivity) const
*/ */
int CompareN(const char *str, size_t count, CaseSensitivity sense = kCaseSensitive) const int CompareN(const char *str, size_t count, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT
{ {
return (sense == kCaseSensitive) ? strncmp(c_str(), str ? str : "", count) return (sense == kCaseSensitive) ? strncmp(c_str(), str ? str : "", count)
: strnicmp(c_str(), str ? str : "", count); : strnicmp(c_str(), str ? str : "", count);
} }
/** Shortcut for Compare(str, kCaseInsensitive). */ /** Shortcut for Compare(str, kCaseInsensitive). */
int CompareI(const plString &str) const { return Compare(str, kCaseInsensitive); } int CompareI(const plString &str) const HS_NOEXCEPT { return Compare(str, kCaseInsensitive); }
/** Shortcut for Compare(str, kCaseInsensitive). */ /** Shortcut for Compare(str, kCaseInsensitive). */
int CompareI(const char *str) const { return Compare(str, kCaseInsensitive); } int CompareI(const char *str) const HS_NOEXCEPT { return Compare(str, kCaseInsensitive); }
/** Shortcut for CompareN(str, kCaseInsensitive). */ /** Shortcut for CompareN(str, kCaseInsensitive). */
int CompareNI(const plString &str, size_t count) const { return CompareN(str, count, kCaseInsensitive); } int CompareNI(const plString &str, size_t count) const HS_NOEXCEPT { return CompareN(str, count, kCaseInsensitive); }
/** Shortcut for CompareN(str, kCaseInsensitive). */ /** Shortcut for CompareN(str, kCaseInsensitive). */
int CompareNI(const char *str, size_t count) const { return CompareN(str, count, kCaseInsensitive); } int CompareNI(const char *str, size_t count) const HS_NOEXCEPT { return CompareN(str, count, kCaseInsensitive); }
/** Operator overload for use in containers which depend on \c std::less. */ /** Operator overload for use in containers which depend on \c std::less. */
bool operator<(const plString &other) const { return Compare(other) < 0; } bool operator<(const plString &other) const HS_NOEXCEPT { return Compare(other) < 0; }
/** Test if this string contains the same string data as \a other. */ /** Test if this string contains the same string data as \a other. */
bool operator==(const char *other) const { return Compare(other) == 0; } bool operator==(const char *other) const HS_NOEXCEPT { return Compare(other) == 0; }
/** Test if this string contains the same string data as \a other. */ /** Test if this string contains the same string data as \a other. */
bool operator==(const plString &other) const { return Compare(other) == 0; } bool operator==(const plString &other) const HS_NOEXCEPT { return Compare(other) == 0; }
/** Inverse of operator==(const char *) const. */ /** Inverse of operator==(const char *) const. */
bool operator!=(const char *other) const { return Compare(other) != 0; } bool operator!=(const char *other) const HS_NOEXCEPT { return Compare(other) != 0; }
/** Inverse of operator==(const plString &) const. */ /** Inverse of operator==(const plString &) const. */
bool operator!=(const plString &other) const { return Compare(other) != 0; } bool operator!=(const plString &other) const HS_NOEXCEPT { return Compare(other) != 0; }
/** Find the index (in bytes) of the first instance of \a ch in this string. /** Find the index (in bytes) of the first instance of \a ch in this string.
* \return -1 if the character was not found. * \return -1 if the character was not found.
*/ */
ssize_t Find(char ch, CaseSensitivity sense = kCaseSensitive) const; ssize_t Find(char ch, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT;
/** Find the index (in bytes) of the last instance of \a ch in this string. /** Find the index (in bytes) of the last instance of \a ch in this string.
* \return -1 if the character was not found. * \return -1 if the character was not found.
*/ */
ssize_t FindLast(char ch, CaseSensitivity sense = kCaseSensitive) const; ssize_t FindLast(char ch, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT;
/** Find the index (in bytes) of the first instance of \a str in this string. /** Find the index (in bytes) of the first instance of \a str in this string.
* \return -1 if the substring was not found. * \return -1 if the substring was not found.
*/ */
ssize_t Find(const char *str, CaseSensitivity sense = kCaseSensitive) const; ssize_t Find(const char *str, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT;
/** Find the index (in bytes) of the first instance of \a str in this string. /** Find the index (in bytes) of the first instance of \a str in this string.
* \return -1 if the substring was not found. * \return -1 if the substring was not found.
*/ */
ssize_t Find(const plString &str, CaseSensitivity sense = kCaseSensitive) const ssize_t Find(const plString &str, CaseSensitivity sense = kCaseSensitive) const HS_NOEXCEPT
{ return Find(str.c_str(), sense); } { return Find(str.c_str(), sense); }
/** Check that this string matches the specified regular expression. /** Check that this string matches the specified regular expression.
@ -645,7 +645,7 @@ public:
{ {
// TODO: This doesn't really use enough bits to be useful when // TODO: This doesn't really use enough bits to be useful when
// size_t is 64-bits. // size_t is 64-bits.
size_t operator()(const plString& str) const size_t operator()(const plString& str) const HS_NOEXCEPT
{ {
size_t hash = 0; size_t hash = 0;
for (size_t i = 0; i < str.GetSize(); ++i) { for (size_t i = 0; i < str.GetSize(); ++i) {
@ -660,7 +660,7 @@ public:
} }
protected: protected:
virtual char fetch_char(const plString& str, size_t index) const virtual char fetch_char(const plString& str, size_t index) const HS_NOEXCEPT
{ return str.CharAt(index); } { return str.CharAt(index); }
}; };
@ -670,21 +670,21 @@ public:
struct hash_i : public hash struct hash_i : public hash
{ {
protected: protected:
virtual char fetch_char(const plString& str, size_t index) const char fetch_char(const plString& str, size_t index) const HS_NOEXCEPT HS_FINAL HS_OVERRIDE
{ return tolower(str.CharAt(index)); } { return tolower(str.CharAt(index)); }
}; };
/** Functor which compares two strings case-insensitively for sorting. */ /** Functor which compares two strings case-insensitively for sorting. */
struct less_i struct less_i
{ {
bool operator()(const plString &_L, const plString &_R) const bool operator()(const plString &_L, const plString &_R) const HS_NOEXCEPT
{ return _L.Compare(_R, kCaseInsensitive) < 0; } { return _L.Compare(_R, kCaseInsensitive) < 0; }
}; };
/** Functor which compares two strings case-insensitively for equality. */ /** Functor which compares two strings case-insensitively for equality. */
struct equal_i struct equal_i
{ {
bool operator()(const plString &_L, const plString &_R) const bool operator()(const plString &_L, const plString &_R) const HS_NOEXCEPT
{ return _L.Compare(_R, kCaseInsensitive) == 0; } { return _L.Compare(_R, kCaseInsensitive) == 0; }
}; };
@ -715,16 +715,16 @@ public:
/** Construct a new empty string stream. The first STRING_STACK_SIZE /** Construct a new empty string stream. The first STRING_STACK_SIZE
* bytes are allocated on the stack for further efficiency. * bytes are allocated on the stack for further efficiency.
*/ */
plStringStream() : fBufSize(STRING_STACK_SIZE), fLength(0) { } plStringStream() HS_NOEXCEPT : fBufSize(STRING_STACK_SIZE), fLength(0) { }
/** Destructor, frees any allocated heap memory owned by the stream. */ /** Destructor, frees any allocated heap memory owned by the stream. */
~plStringStream() { if (ICanHasHeap()) delete [] fBuffer; } ~plStringStream() HS_NOEXCEPT { if (ICanHasHeap()) delete [] fBuffer; }
plStringStream(const plStringStream &) = delete; plStringStream(const plStringStream &) = delete;
plStringStream &operator=(const plStringStream &) = delete; plStringStream &operator=(const plStringStream &) = delete;
/** Move operator */ /** Move operator */
plStringStream(plStringStream &&move) plStringStream(plStringStream &&move) HS_NOEXCEPT
: fBufSize(move.fBufSize), fLength(move.fLength) : fBufSize(move.fBufSize), fLength(move.fLength)
{ {
memcpy(fShort, move.fShort, sizeof(fShort)); memcpy(fShort, move.fShort, sizeof(fShort));
@ -732,7 +732,7 @@ public:
} }
/** Move assignment operator. */ /** Move assignment operator. */
plStringStream &operator=(plStringStream &&move) plStringStream &operator=(plStringStream &&move) HS_NOEXCEPT
{ {
memcpy(fShort, move.fShort, sizeof(fShort)); memcpy(fShort, move.fShort, sizeof(fShort));
fBufSize = move.fBufSize; fBufSize = move.fBufSize;
@ -780,13 +780,13 @@ public:
/** Returns a pointer to the beginning of the stream buffer. /** Returns a pointer to the beginning of the stream buffer.
* \warning This pointer is not null-terminated. * \warning This pointer is not null-terminated.
*/ */
const char *GetRawBuffer() const const char *GetRawBuffer() const HS_NOEXCEPT
{ {
return ICanHasHeap() ? fBuffer : fShort; return ICanHasHeap() ? fBuffer : fShort;
} }
/** Return the size (in bytes) of the stream's data. */ /** Return the size (in bytes) of the stream's data. */
size_t GetLength() const { return fLength; } size_t GetLength() const HS_NOEXCEPT { return fLength; }
/** Convert the stream's data to a UTF-8 string. */ /** Convert the stream's data to a UTF-8 string. */
plString GetString() const { return plString::FromUtf8(GetRawBuffer(), fLength); } plString GetString() const { return plString::FromUtf8(GetRawBuffer(), fLength); }
@ -796,7 +796,7 @@ public:
* with as much space as it had before, making this method more * with as much space as it had before, making this method more
* useful for re-using string streams in loops. * useful for re-using string streams in loops.
*/ */
void Truncate() { fLength = 0; } void Truncate() HS_NOEXCEPT { fLength = 0; }
private: private:
union { union {
@ -805,7 +805,7 @@ private:
}; };
size_t fBufSize, fLength; size_t fBufSize, fLength;
bool ICanHasHeap() const { return fBufSize > STRING_STACK_SIZE; } bool ICanHasHeap() const HS_NOEXCEPT { return fBufSize > STRING_STACK_SIZE; }
}; };
/** \p strlen implementation for plUniChar based C-style string buffers. */ /** \p strlen implementation for plUniChar based C-style string buffers. */

Write Preview
Loading…
Cancel
Save