diff options
Diffstat (limited to 'vendor/zgui/libs/imgui_test_engine/thirdparty/Str')
| -rw-r--r-- | vendor/zgui/libs/imgui_test_engine/thirdparty/Str/README.md | 71 | ||||
| -rw-r--r-- | vendor/zgui/libs/imgui_test_engine/thirdparty/Str/Str.h | 658 |
2 files changed, 0 insertions, 729 deletions
diff --git a/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/README.md b/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/README.md deleted file mode 100644 index 3573ea9..0000000 --- a/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/README.md +++ /dev/null @@ -1,71 +0,0 @@ -``` -Str -Simple C++ string type with an optional local buffer, by Omar Cornut -https://github.com/ocornut/str - -LICENSE -This software is in the public domain. Where that dedication is not -recognized, you are granted a perpetual, irrevocable license to copy, -distribute, and modify this file as you see fit. - -USAGE -Include Str.h in whatever places need to refer to it. -In ONE .cpp file, write '#define STR_IMPLEMENTATION' before the #include. -This expands out the actual implementation into that C/C++ file. - -NOTES -- This isn't a fully featured string class. -- It is a simple, bearable replacement to std::string that isn't heap abusive nor bloated (can actually be debugged by humans!). -- String are mutable. We don't maintain size so length() is not-constant time. -- Maximum string size currently limited to 2 MB (we allocate 21 bits to hold capacity). -- Local buffer size is currently limited to 1023 bytes (we allocate 10 bits to hold local buffer size). -- We could easily raise those limits if we are ok to increase the structure overhead in 32-bits mode. -- In "non-owned" mode for literals/reference we don't do any tracking/counting of references. -- Overhead is 8-bytes in 32-bits, 16-bytes in 64-bits (12 + alignment). -- I'm using this code but it hasn't been tested thoroughly. - -The idea is that you can provide an arbitrary sized local buffer if you expect string to fit -most of the time, and then you avoid using costly heap. - -No local buffer, always use heap, sizeof()==8~16 (depends if your pointers are 32-bits or 64-bits) - - Str s = "hey"; // use heap - -With a local buffer of 16 bytes, sizeof() == 8~16 + 16 bytes. - - Str16 s = "filename.h"; // copy into local buffer - Str16 s = "long_filename_not_very_long_but_longer_than_expected.h"; // use heap - -With a local buffer of 256 bytes, sizeof() == 8~16 + 256 bytes. - - Str256 s = "long_filename_not_very_long_but_longer_than_expected.h"; // copy into local buffer - -Common sizes are defined at the bottom of Str.h, you may define your own. - -Functions: - - Str256 s; - s.set("hello sailor"); // set (copy) - s.setf("%s/%s.tmp", folder, filename); // set (w/format) - s.append("hello"); // append. cost a length() calculation! - s.appendf("hello %d", 42); // append (w/format). cost a length() calculation! - s.set_ref("Hey!"); // set (literal/reference, just copy pointer, no tracking) - -Constructor helper for format string: add a trailing 'f' to the type. Underlying type is the same. - - Str256f filename("%s/%s.tmp", folder, filename); // construct (w/format) - fopen(Str256f("%s/%s.tmp, folder, filename).c_str(), "rb"); // construct (w/format), use as function param, destruct - -Constructor helper for reference/literal: - - StrRef ref("literal"); // copy pointer, no allocation, no string copy - StrRef ref2(GetDebugName()); // copy pointer. no tracking of anything whatsoever, know what you are doing! - -All StrXXX types derives from Str and instance hold the local buffer capacity. -So you can pass e.g. Str256* to a function taking base type Str* and it will be functional! - - void MyFunc(Str& s) { s = "Hello"; } // will use local buffer if available in Str instance - -(Using a template e.g. Str<N> we could remove the LocalBufSize storage but it would make passing typed Str<> to functions tricky. - Instead we don't use template so you can pass them around as the base type Str*. Also, templates are ugly.) -``` diff --git a/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/Str.h b/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/Str.h deleted file mode 100644 index ff197d3..0000000 --- a/vendor/zgui/libs/imgui_test_engine/thirdparty/Str/Str.h +++ /dev/null @@ -1,658 +0,0 @@ -// Str v0.32 -// Simple C++ string type with an optional local buffer, by Omar Cornut -// https://github.com/ocornut/str - -// LICENSE -// This software is in the public domain. Where that dedication is not -// recognized, you are granted a perpetual, irrevocable license to copy, -// distribute, and modify this file as you see fit. - -// USAGE -// Include this file in whatever places need to refer to it. -// In ONE .cpp file, write '#define STR_IMPLEMENTATION' before the #include of this file. -// This expands out the actual implementation into that C/C++ file. - - -/* -- This isn't a fully featured string class. -- It is a simple, bearable replacement to std::string that isn't heap abusive nor bloated (can actually be debugged by humans). -- String are mutable. We don't maintain size so length() is not-constant time. -- Maximum string size currently limited to 2 MB (we allocate 21 bits to hold capacity). -- Local buffer size is currently limited to 1023 bytes (we allocate 10 bits to hold local buffer size). -- In "non-owned" mode for literals/reference we don't do any tracking/counting of references. -- Overhead is 8-bytes in 32-bits, 16-bytes in 64-bits (12 + alignment). -- This code hasn't been tested very much. it is probably incomplete or broken. Made it for my own use. - -The idea is that you can provide an arbitrary sized local buffer if you expect string to fit -most of the time, and then you avoid using costly heap. - -No local buffer, always use heap, sizeof()==8~16 (depends if your pointers are 32-bits or 64-bits) - - Str s = "hey"; - -With a local buffer of 16 bytes, sizeof() == 8~16 + 16 bytes. - - Str16 s = "filename.h"; // copy into local buffer - Str16 s = "long_filename_not_very_long_but_longer_than_expected.h"; // use heap - -With a local buffer of 256 bytes, sizeof() == 8~16 + 256 bytes. - - Str256 s = "long_filename_not_very_long_but_longer_than_expected.h"; // copy into local buffer - -Common sizes are defined at the bottom of Str.h, you may define your own. - -Functions: - - Str256 s; - s.set("hello sailor"); // set (copy) - s.setf("%s/%s.tmp", folder, filename); // set (w/format) - s.append("hello"); // append. cost a length() calculation! - s.appendf("hello %d", 42); // append (w/format). cost a length() calculation! - s.set_ref("Hey!"); // set (literal/reference, just copy pointer, no tracking) - -Constructor helper for format string: add a trailing 'f' to the type. Underlying type is the same. - - Str256f filename("%s/%s.tmp", folder, filename); // construct (w/format) - fopen(Str256f("%s/%s.tmp, folder, filename).c_str(), "rb"); // construct (w/format), use as function param, destruct - -Constructor helper for reference/literal: - - StrRef ref("literal"); // copy pointer, no allocation, no string copy - StrRef ref2(GetDebugName()); // copy pointer. no tracking of anything whatsoever, know what you are doing! - -All StrXXX types derives from Str and instance hold the local buffer capacity. So you can pass e.g. Str256* to a function taking base type Str* and it will be functional. - - void MyFunc(Str& s) { s = "Hello"; } // will use local buffer if available in Str instance - -(Using a template e.g. Str<N> we could remove the LocalBufSize storage but it would make passing typed Str<> to functions tricky. - Instead we don't use template so you can pass them around as the base type Str*. Also, templates are ugly.) -*/ - -/* - CHANGELOG - 0.32 - added owned() accessor. - 0.31 - fixed various warnings. - 0.30 - turned into a single header file, removed Str.cpp. - 0.29 - fixed bug when calling reserve on non-owned strings (ie. when using StrRef or set_ref), and fixed <string> include. - 0.28 - breaking change: replaced Str32 by Str30 to avoid collision with Str32 from MacTypes.h . - 0.27 - added STR_API and basic .natvis file. - 0.26 - fixed set(cont char* src, const char* src_end) writing null terminator to the wrong position. - 0.25 - allow set(const char* NULL) or operator= NULL to clear the string. note that set() from range or other types are not allowed. - 0.24 - allow set_ref(const char* NULL) to clear the string. include fixes for linux. - 0.23 - added append(char). added append_from(int idx, XXX) functions. fixed some compilers warnings. - 0.22 - documentation improvements, comments. fixes for some compilers. - 0.21 - added StrXXXf() constructor to construct directly from a format string. -*/ - -/* -TODO -- Since we lose 4-bytes of padding on 64-bits architecture, perhaps just spread the header to 8-bytes and lift size limits? -- More functions/helpers. -*/ - -#ifndef STR_INCLUDED -#define STR_INCLUDED - -//------------------------------------------------------------------------- -// CONFIGURATION -//------------------------------------------------------------------------- - -#ifndef STR_MEMALLOC -#define STR_MEMALLOC malloc -#include <stdlib.h> -#endif -#ifndef STR_MEMFREE -#define STR_MEMFREE free -#include <stdlib.h> -#endif -#ifndef STR_ASSERT -#define STR_ASSERT assert -#include <assert.h> -#endif -#ifndef STR_API -#define STR_API -#endif -#include <stdarg.h> // for va_list -#include <string.h> // for strlen, strcmp, memcpy, etc. - -// Configuration: #define STR_SUPPORT_STD_STRING 0 to disable setters variants using const std::string& (on by default) -#ifndef STR_SUPPORT_STD_STRING -#define STR_SUPPORT_STD_STRING 1 -#endif - -// Configuration: #define STR_DEFINE_STR32 1 to keep defining Str32/Str32f, but be warned: on macOS/iOS, MacTypes.h also defines a type named Str32. -#ifndef STR_DEFINE_STR32 -#define STR_DEFINE_STR32 0 -#endif - -#if STR_SUPPORT_STD_STRING -#include <string> -#endif - -//------------------------------------------------------------------------- -// HEADERS -//------------------------------------------------------------------------- - -// This is the base class that you can pass around -// Footprint is 8-bytes (32-bits arch) or 16-bytes (64-bits arch) -class STR_API Str -{ - char* Data; // Point to LocalBuf() or heap allocated - int Capacity : 21; // Max 2 MB - int LocalBufSize : 10; // Max 1023 bytes - unsigned int Owned : 1; // Set when we have ownership of the pointed data (most common, unless using set_ref() method or StrRef constructor) - -public: - inline char* c_str() { return Data; } - inline const char* c_str() const { return Data; } - inline bool empty() const { return Data[0] == 0; } - inline int length() const { return (int)strlen(Data); } // by design, allow user to write into the buffer at any time - inline int capacity() const { return Capacity; } - inline bool owned() const { return Owned ? true : false; } - - inline void set_ref(const char* src); - int setf(const char* fmt, ...); - int setfv(const char* fmt, va_list args); - int setf_nogrow(const char* fmt, ...); - int setfv_nogrow(const char* fmt, va_list args); - int append(char c); - int append(const char* s, const char* s_end = NULL); - int appendf(const char* fmt, ...); - int appendfv(const char* fmt, va_list args); - int append_from(int idx, char c); - int append_from(int idx, const char* s, const char* s_end = NULL); // If you know the string length or want to append from a certain point - int appendf_from(int idx, const char* fmt, ...); - int appendfv_from(int idx, const char* fmt, va_list args); - - void clear(); - void reserve(int cap); - void reserve_discard(int cap); - void shrink_to_fit(); - - inline char& operator[](size_t i) { return Data[i]; } - inline char operator[](size_t i) const { return Data[i]; } - //explicit operator const char*() const{ return Data; } - - inline Str(); - inline Str(const char* rhs); - inline void set(const char* src); - inline void set(const char* src, const char* src_end); - inline Str& operator=(const char* rhs) { set(rhs); return *this; } - inline bool operator==(const char* rhs) const { return strcmp(c_str(), rhs) == 0; } - - inline Str(const Str& rhs); - inline void set(const Str& src); - inline Str& operator=(const Str& rhs) { set(rhs); return *this; } - inline bool operator==(const Str& rhs) const { return strcmp(c_str(), rhs.c_str()) == 0; } - -#if STR_SUPPORT_STD_STRING - inline Str(const std::string& rhs); - inline void set(const std::string& src); - inline Str& operator=(const std::string& rhs) { set(rhs); return *this; } - inline bool operator==(const std::string& rhs)const { return strcmp(c_str(), rhs.c_str()) == 0; } -#endif - - // Destructor for all variants - inline ~Str() - { - if (Owned && !is_using_local_buf()) - STR_MEMFREE(Data); - } - - static char* EmptyBuffer; - -protected: - inline char* local_buf() { return (char*)this + sizeof(Str); } - inline const char* local_buf() const { return (char*)this + sizeof(Str); } - inline bool is_using_local_buf() const { return Data == local_buf() && LocalBufSize != 0; } - - // Constructor for StrXXX variants with local buffer - Str(unsigned short local_buf_size) - { - STR_ASSERT(local_buf_size < 1024); - Data = local_buf(); - Data[0] = '\0'; - Capacity = local_buf_size; - LocalBufSize = local_buf_size; - Owned = 1; - } -}; - -void Str::set(const char* src) -{ - // We allow set(NULL) or via = operator to clear the string. - if (src == NULL) - { - clear(); - return; - } - int buf_len = (int)strlen(src)+1; - if (Capacity < buf_len) - reserve_discard(buf_len); - memcpy(Data, src, (size_t)buf_len); - Owned = 1; -} - -void Str::set(const char* src, const char* src_end) -{ - STR_ASSERT(src != NULL && src_end >= src); - int buf_len = (int)(src_end-src)+1; - if ((int)Capacity < buf_len) - reserve_discard(buf_len); - memcpy(Data, src, (size_t)(buf_len - 1)); - Data[buf_len-1] = 0; - Owned = 1; -} - -void Str::set(const Str& src) -{ - int buf_len = (int)strlen(src.c_str())+1; - if ((int)Capacity < buf_len) - reserve_discard(buf_len); - memcpy(Data, src.c_str(), (size_t)buf_len); - Owned = 1; -} - -#if STR_SUPPORT_STD_STRING -void Str::set(const std::string& src) -{ - int buf_len = (int)src.length()+1; - if ((int)Capacity < buf_len) - reserve_discard(buf_len); - memcpy(Data, src.c_str(), (size_t)buf_len); - Owned = 1; -} -#endif - -inline void Str::set_ref(const char* src) -{ - if (Owned && !is_using_local_buf()) - STR_MEMFREE(Data); - Data = src ? (char*)src : EmptyBuffer; - Capacity = 0; - Owned = 0; -} - -Str::Str() -{ - Data = EmptyBuffer; // Shared READ-ONLY initial buffer for 0 capacity - Capacity = 0; - LocalBufSize = 0; - Owned = 0; -} - -Str::Str(const Str& rhs) : Str() -{ - set(rhs); -} - -Str::Str(const char* rhs) : Str() -{ - set(rhs); -} - -#if STR_SUPPORT_STD_STRING -Str::Str(const std::string& rhs) : Str() -{ - set(rhs); -} -#endif - -// Literal/reference string -class StrRef : public Str -{ -public: - StrRef(const char* s) : Str() { set_ref(s); } -}; - -// Types embedding a local buffer -// NB: we need to override the constructor and = operator for both Str& and TYPENAME (without the later compiler will call a default copy operator) -#if STR_SUPPORT_STD_STRING - -#define STR_DEFINETYPE(TYPENAME, LOCALBUFSIZE) \ -class TYPENAME : public Str \ -{ \ - char local_buf[LOCALBUFSIZE]; \ -public: \ - TYPENAME() : Str(LOCALBUFSIZE) {} \ - TYPENAME(const Str& rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME(const char* rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME(const TYPENAME& rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME(const std::string& rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME& operator=(const char* rhs) { set(rhs); return *this; } \ - TYPENAME& operator=(const Str& rhs) { set(rhs); return *this; } \ - TYPENAME& operator=(const TYPENAME& rhs) { set(rhs); return *this; } \ - TYPENAME& operator=(const std::string& rhs) { set(rhs); return *this; } \ -}; - -#else - -#define STR_DEFINETYPE(TYPENAME, LOCALBUFSIZE) \ -class TYPENAME : public Str \ -{ \ - char local_buf[LOCALBUFSIZE]; \ -public: \ - TYPENAME() : Str(LOCALBUFSIZE) {} \ - TYPENAME(const Str& rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME(const char* rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME(const TYPENAME& rhs) : Str(LOCALBUFSIZE) { set(rhs); } \ - TYPENAME& operator=(const char* rhs) { set(rhs); return *this; } \ - TYPENAME& operator=(const Str& rhs) { set(rhs); return *this; } \ - TYPENAME& operator=(const TYPENAME& rhs) { set(rhs); return *this; } \ -}; - -#endif - -// Disable PVS-Studio warning V730: Not all members of a class are initialized inside the constructor (local_buf is not initialized and that is fine) -// -V:STR_DEFINETYPE:730 - -// Helper to define StrXXXf constructors -#define STR_DEFINETYPE_F(TYPENAME, TYPENAME_F) \ -class TYPENAME_F : public TYPENAME \ -{ \ -public: \ - TYPENAME_F(const char* fmt, ...) : TYPENAME() { va_list args; va_start(args, fmt); setfv(fmt, args); va_end(args); } \ -}; - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunused-private-field" // warning : private field 'local_buf' is not used -#endif - -// Declaring types for common sizes here -STR_DEFINETYPE(Str16, 16) -STR_DEFINETYPE(Str30, 30) -STR_DEFINETYPE(Str64, 64) -STR_DEFINETYPE(Str128, 128) -STR_DEFINETYPE(Str256, 256) -STR_DEFINETYPE(Str512, 512) - -// Declaring helper constructors to pass in format strings in one statement -STR_DEFINETYPE_F(Str16, Str16f) -STR_DEFINETYPE_F(Str30, Str30f) -STR_DEFINETYPE_F(Str64, Str64f) -STR_DEFINETYPE_F(Str128, Str128f) -STR_DEFINETYPE_F(Str256, Str256f) -STR_DEFINETYPE_F(Str512, Str512f) - -#if STR_DEFINE_STR32 -STR_DEFINETYPE(Str32, 32) -STR_DEFINETYPE_F(Str32, Str32f) -#endif - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -#endif // #ifndef STR_INCLUDED - -//------------------------------------------------------------------------- -// IMPLEMENTATION -//------------------------------------------------------------------------- - -#ifdef STR_IMPLEMENTATION - -#include <stdio.h> // for vsnprintf - -// On some platform vsnprintf() takes va_list by reference and modifies it. -// va_copy is the 'correct' way to copy a va_list but Visual Studio prior to 2013 doesn't have it. -#ifndef va_copy -#define va_copy(dest, src) (dest = src) -#endif - -// Static empty buffer we can point to for empty strings -// Pointing to a literal increases the like-hood of getting a crash if someone attempts to write in the empty string buffer. -char* Str::EmptyBuffer = (char*)"\0NULL"; - -// Clear -void Str::clear() -{ - if (Owned && !is_using_local_buf()) - STR_MEMFREE(Data); - if (LocalBufSize) - { - Data = local_buf(); - Data[0] = '\0'; - Capacity = LocalBufSize; - Owned = 1; - } - else - { - Data = EmptyBuffer; - Capacity = 0; - Owned = 0; - } -} - -// Reserve memory, preserving the current of the buffer -void Str::reserve(int new_capacity) -{ - if (new_capacity <= Capacity) - return; - - char* new_data; - if (new_capacity < LocalBufSize) - { - // Disowned -> LocalBuf - new_data = local_buf(); - new_capacity = LocalBufSize; - } - else - { - // Disowned or LocalBuf -> Heap - new_data = (char*)STR_MEMALLOC((size_t)new_capacity * sizeof(char)); - } - - // string in Data might be longer than new_capacity if it wasn't owned, don't copy too much -#ifdef _MSC_VER - strncpy_s(new_data, (size_t)new_capacity, Data, (size_t)new_capacity - 1); -#else - strncpy(new_data, Data, (size_t)new_capacity - 1); -#endif - new_data[new_capacity - 1] = 0; - - if (Owned && !is_using_local_buf()) - STR_MEMFREE(Data); - - Data = new_data; - Capacity = new_capacity; - Owned = 1; -} - -// Reserve memory, discarding the current of the buffer (if we expect to be fully rewritten) -void Str::reserve_discard(int new_capacity) -{ - if (new_capacity <= Capacity) - return; - - if (Owned && !is_using_local_buf()) - STR_MEMFREE(Data); - - if (new_capacity < LocalBufSize) - { - // Disowned -> LocalBuf - Data = local_buf(); - Capacity = LocalBufSize; - } - else - { - // Disowned or LocalBuf -> Heap - Data = (char*)STR_MEMALLOC((size_t)new_capacity * sizeof(char)); - Capacity = new_capacity; - } - Owned = 1; -} - -void Str::shrink_to_fit() -{ - if (!Owned || is_using_local_buf()) - return; - int new_capacity = length() + 1; - if (Capacity <= new_capacity) - return; - - char* new_data = (char*)STR_MEMALLOC((size_t)new_capacity * sizeof(char)); - memcpy(new_data, Data, (size_t)new_capacity); - STR_MEMFREE(Data); - Data = new_data; - Capacity = new_capacity; -} - -// FIXME: merge setfv() and appendfv()? -int Str::setfv(const char* fmt, va_list args) -{ - // Needed for portability on platforms where va_list are passed by reference and modified by functions - va_list args2; - va_copy(args2, args); - - // MSVC returns -1 on overflow when writing, which forces us to do two passes - // FIXME-OPT: Find a way around that. -#ifdef _MSC_VER - int len = vsnprintf(NULL, 0, fmt, args); - STR_ASSERT(len >= 0); - - if (Capacity < len + 1) - reserve_discard(len + 1); - len = vsnprintf(Data, len + 1, fmt, args2); -#else - // First try - int len = vsnprintf(Owned ? Data : NULL, Owned ? (size_t)Capacity : 0, fmt, args); - STR_ASSERT(len >= 0); - - if (Capacity < len + 1) - { - reserve_discard(len + 1); - len = vsnprintf(Data, (size_t)len + 1, fmt, args2); - } -#endif - - STR_ASSERT(Owned); - return len; -} - -int Str::setf(const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - int len = setfv(fmt, args); - va_end(args); - return len; -} - -int Str::setfv_nogrow(const char* fmt, va_list args) -{ - STR_ASSERT(Owned); - - if (Capacity == 0) - return 0; - - int w = vsnprintf(Data, (size_t)Capacity, fmt, args); - Data[Capacity - 1] = 0; - Owned = 1; - return (w == -1) ? Capacity - 1 : w; -} - -int Str::setf_nogrow(const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - int len = setfv_nogrow(fmt, args); - va_end(args); - return len; -} - -int Str::append_from(int idx, char c) -{ - int add_len = 1; - if (Capacity < idx + add_len + 1) - reserve(idx + add_len + 1); - Data[idx] = c; - Data[idx + add_len] = 0; - STR_ASSERT(Owned); - return add_len; -} - -int Str::append_from(int idx, const char* s, const char* s_end) -{ - if (!s_end) - s_end = s + strlen(s); - int add_len = (int)(s_end - s); - if (Capacity < idx + add_len + 1) - reserve(idx + add_len + 1); - memcpy(Data + idx, (const void*)s, (size_t)add_len); - Data[idx + add_len] = 0; // Our source data isn't necessarily zero-terminated - STR_ASSERT(Owned); - return add_len; -} - -// FIXME: merge setfv() and appendfv()? -int Str::appendfv_from(int idx, const char* fmt, va_list args) -{ - // Needed for portability on platforms where va_list are passed by reference and modified by functions - va_list args2; - va_copy(args2, args); - - // MSVC returns -1 on overflow when writing, which forces us to do two passes - // FIXME-OPT: Find a way around that. -#ifdef _MSC_VER - int add_len = vsnprintf(NULL, 0, fmt, args); - STR_ASSERT(add_len >= 0); - - if (Capacity < idx + add_len + 1) - reserve(idx + add_len + 1); - add_len = vsnprintf(Data + idx, add_len + 1, fmt, args2); -#else - // First try - int add_len = vsnprintf(Owned ? Data + idx : NULL, Owned ? (size_t)(Capacity - idx) : 0, fmt, args); - STR_ASSERT(add_len >= 0); - - if (Capacity < idx + add_len + 1) - { - reserve(idx + add_len + 1); - add_len = vsnprintf(Data + idx, (size_t)add_len + 1, fmt, args2); - } -#endif - - STR_ASSERT(Owned); - return add_len; -} - -int Str::appendf_from(int idx, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - int len = appendfv_from(idx, fmt, args); - va_end(args); - return len; -} - -int Str::append(char c) -{ - int cur_len = length(); - return append_from(cur_len, c); -} - -int Str::append(const char* s, const char* s_end) -{ - int cur_len = length(); - return append_from(cur_len, s, s_end); -} - -int Str::appendfv(const char* fmt, va_list args) -{ - int cur_len = length(); - return appendfv_from(cur_len, fmt, args); -} - -int Str::appendf(const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - int len = appendfv(fmt, args); - va_end(args); - return len; -} - -#endif // #define STR_IMPLEMENTATION - -//------------------------------------------------------------------------- |