26 #ifndef __UT_WorkBuffer_h__
27 #define __UT_WorkBuffer_h__
55 #define UT_INITIAL_BUFFER_SIZE 2000
70 : myBuffer(myStackBuffer)
78 : myBuffer(myStackBuffer)
86 : myBuffer(myStackBuffer)
94 : myBuffer(myStackBuffer)
102 : myBuffer(myStackBuffer)
110 : myBuffer(myStackBuffer)
119 if (myBuffer != myStackBuffer)
151 const char *
buffer()
const {
return myBuffer; }
179 void release(
bool recompute_length =
false);
180 void releaseSetLength(
exint new_length);
184 int64 getMemoryUsage(
bool inclusive)
const;
197 myString = myBuffer.lock();
210 char *
string()
const {
return myString; }
219 myBuffer.release(recompute_length);
228 myString = myBuffer.lock();
247 return myBuffer[idx];
262 return myBuffer[myLength - 1];
266 int isNullTerminated()
const;
285 append(str.c_str(), str.length());
296 return (::strcmp(str, myBuffer) == 0);
301 if (!(
const char *)str)
303 return (::strcmp(str, myBuffer) == 0);
312 return (::memcmp(myBuffer, buf.myBuffer, myLength) == 0);
317 return !(*
this == str);
322 return !(*
this == str);
327 return !(*
this ==
buf);
334 void growBufferIfNeeded()
340 while (myLength+1 > myAllocatedSize)
378 growBufferIfNeeded();
381 myLength = ::strlen(myBuffer);
389 return ::strlen(myBuffer);
407 void protectedStrcat(
const char *str,
bool force_quote=
false);
417 void fullyProtectedStrcat(
const char *str,
bool force_quote=
false);
418 void fullyProtectedBinaryStrcat(
419 const char *str,
exint size,
bool force_quote=
false);
429 append(src, ::strnlen(src, len));
435 void strcatFirstWord(
const char *
src);
441 return ::strcmp(myBuffer, src);
448 return ::strncmp(myBuffer, src, n);
455 return ::strdup(myBuffer);
462 if (myLockCount) {
UT_ASSERT(0);
return; }
470 return (myLength == 0);
485 if (offset < 0)
return;
486 if (offset >= myLength)
488 if (myLockCount) {
UT_ASSERT(0);
return; }
490 growBufferIfNeeded();
491 myBuffer[myLength] =
'\0';
521 bool getline(std::istream &is);
522 bool getline(FILE *fp);
531 const char *comment_chars =
"#",
532 const char *separators =
" \t\n\r");
534 const char *comment_chars =
"#",
535 const char *separators =
" \t\n\r");
537 const char *comment_chars =
"#",
538 const char *separators =
" \t\n\r");
546 int sprintf(
const char *fmt, ...)
548 int appendSprintf(
const char *fmt, ...)
556 template<typename... Args>
560 return appendFormat(fmt, args...);
565 template<
typename... Args>
568 if (myLockCount) {
UT_ASSERT(0);
return 0; }
574 size_t nb_needed =
f.format(
w, fmt, {args...});
576 myLength += nb_needed;
577 growBufferIfNeeded();
580 w.setBuffer(myBuffer + myLength - nb_needed, nb_needed);
581 f.format(
w, fmt, {args...});
583 myBuffer[myLength] =
'\0';
590 template<
typename... Args>
594 return appendPrint(args...);
600 template<
typename... Args>
605 template<
typename T,
typename... Args>
609 newbytes = appendFormat(
"{}", value);
611 if (!isEmpty() && last() !=
'\n')
616 newbytes += appendPrint(args...);
624 if (myLockCount) {
UT_ASSERT(0);
return; }
627 growBufferIfNeeded();
628 myBuffer[myLength - 1] = character;
629 myBuffer[myLength] =
'\0';
633 void appendPrintMemory(
int64 mem);
637 if (myLockCount) {
UT_ASSERT(0);
return; }
640 growBufferIfNeeded();
641 for (
int i = n; i > 0; i--)
642 myBuffer[myLength - i] = character;
643 myBuffer[myLength] =
'\0';
654 if (myLockCount) {
UT_ASSERT(0);
return; }
657 growBufferIfNeeded();
658 ::memcpy(myBuffer + myLength - len, buf, len);
659 myBuffer[myLength] =
'\0';
664 if (myLockCount) {
UT_ASSERT(0);
return; }
668 growBufferIfNeeded();
669 ::memcpy(myBuffer + myLength - size, data, size);
670 myBuffer[myLength] =
'\0';
677 append(str, ::strlen(str));
684 append((
const char *)str);
747 if (myLockCount) {
UT_ASSERT(0);
return; }
750 growBufferIfNeeded();
751 ::memmove(myBuffer+1, myBuffer, myLength);
752 myBuffer[0] = character;
756 if (myLockCount) {
UT_ASSERT(0);
return; }
760 growBufferIfNeeded();
761 ::memmove(myBuffer+size, myBuffer, myLength+1 - size);
762 ::memcpy(myBuffer, data, size);
768 prepend(str, ::strlen(str));
775 prepend((
const char *)str);
797 if (myLockCount) {
UT_ASSERT(0);
return; }
800 myLength -= by_length;
802 myBuffer[myLength] =
'\0';
810 if (new_length >= myLength)
812 UT_ASSERT(0 &&
"Truncating beyond buffer extent");
815 backup(myLength-new_length);
822 if (myLockCount) {
UT_ASSERT(0);
return; }
824 while( myLength > 0 && myBuffer[myLength-1] != c )
826 myBuffer[myLength] =
'\0';
831 if (myLockCount) {
UT_ASSERT(0);
return; }
834 myLength -= by_length;
836 for (
int i=0; i<myLength; i++)
837 myBuffer[i] = myBuffer[by_length+i];
838 myBuffer[myLength] =
'\0';
843 const char *
findChar(
char c,
int occurance_number = 1)
const
845 return findCharFrom(c, 0, occurance_number);
848 const char *
lastChar(
char c,
int occurance_number = 1)
const
850 if (myLockCount) {
UT_ASSERT(0);
return NULL; }
854 for (
exint i = myLength; i --> 0;)
859 if(occurance_number <= 0)
861 return (myBuffer + i);
870 int occurance_number = 1)
const
872 if (myLockCount) {
UT_ASSERT(0);
return NULL; }
876 if (position < 0 || position >= myLength) {
return NULL; }
878 for(
exint i = position; i < myLength; ++i)
883 if(occurance_number <= 0)
885 return (myBuffer + i);
905 bool getNextToken(
const char *(&
string),
909 void copyIntoString(
UT_String &str)
const;
913 void copyIntoString(
char *str,
exint max_length)
const;
926 std::
string toStdString()
const
933 bool stripComments(
char comment_char =
'#');
938 int strip(
const char *chars);
941 void removeTrailingSpaceLines();
944 bool removeTrailingSpace();
947 bool removeLeadingSpace();
950 bool removeTrailingDigits();
959 void makeIndentString(
exint indent,
exint tabstop=8);
967 ::memmove(myBuffer, myBuffer + n, myLength);
972 myBuffer[myLength] =
'\0';
978 int substitute(
const char *
find,
const char *replacement,
int count);
983 return substitute(find, replacement, !
all ? 1 : -1);
996 const char *to_pattern,
997 const char *from_name,
998 const char *from_pattern);
1006 void setFromUTF16(
const utf16 *str);
1011 void setAsUTF16(
const utf8 *str);
1028 bool this_stack = (myBuffer == myStackBuffer);
1029 bool other_stack = (other.myBuffer == other.myStackBuffer);
1031 if (this_stack && other_stack)
1035 size_t max_size = (myLength > other.myLength) ? myLength
1038 UTswap(myStackBuffer, other.myStackBuffer, max_size + 1);
1040 else if (this_stack && !other_stack)
1042 ::memcpy(other.myStackBuffer, myStackBuffer, myLength + 1);
1043 myBuffer = other.myBuffer;
1044 other.myBuffer = other.myStackBuffer;
1046 else if (!this_stack && other_stack)
1048 ::memcpy(myStackBuffer, other.myStackBuffer, other.myLength + 1);
1049 other.myBuffer = myBuffer;
1050 myBuffer = myStackBuffer;
1053 UTswap(myBuffer, other.myBuffer);
1054 UTswap(myAllocatedSize, other.myAllocatedSize);
1055 UTswap(myLength, other.myLength);
1056 UTswap(myLockCount, other.myLockCount);
1061 const char *
begin()
const {
return myBuffer; }
1063 const char *
end()
const {
return myBuffer + myLength; }
1068 struct do_narrow {};
1073 : myBuffer(myStackBuffer)
1082 : myBuffer(myStackBuffer)
1099 int myLockCount = 0;
1104 static inline size_t
1117 template <
typename T>
1124 for (
auto&& item : items)
1130 out = std::move(wbuf);
1141 template <
typename T>
1158 if (result.
last() !=
'/' && str_arg.
first() !=
'/')
1165 if (result.
last() ==
'/' && str_arg.
first() ==
'/')
1170 if (!view.isEmpty())
1171 result.
append(view.data(), view.length());
1174 template <
typename T,
typename... Args>
size_t print(const Args &...args)
vbool4 insert(const vbool4 &a, bool val)
Helper: substitute val for a[i].
std::basic_string< Char > vsprintf(const S &format, basic_format_args< basic_printf_context_t< type_identity_t< Char >>> args)
SYS_FORCE_INLINE void append(const UT_StringRef &str)
std::string upper(string_view a)
Return an all-upper case version of a (locale-independent).
string_view OIIO_API strip(string_view str, string_view chars=string_view())
GT_API const UT_StringHolder filename
SYS_FORCE_INLINE exint length() const
void UTstringJoin(UT_StringHolder &out, const UT_StringHolder &sep, const T &items)
#define SYS_DEPRECATED(__V__)
SYS_FORCE_INLINE void strcpy(const UT_StringRef &src)
void write(exint offset, const UT_StringHolder &src)
SYS_FORCE_INLINE exint getAllocatedSize() const
SYS_FORCE_INLINE char * operator*() const
SYS_FORCE_INLINE bool operator==(const UT_String &str) const
SYS_FORCE_INLINE UT_WorkBuffer(const char *data, exint size)
SYS_FORCE_INLINE void strncat(const char *src, exint len)
SYS_FORCE_INLINE UT_WorkBuffer(const UT_StringRef &str)
SYS_FORCE_INLINE UT_WorkBuffer(const char *str)
void append(exint n, char character)
SYS_FORCE_INLINE const char * buffer() const
SYS_FORCE_INLINE void strcpy(const char *src)
SYS_FORCE_INLINE void release(bool recompute_length=false)
You can manually release the buffer.
const char * findCharFrom(char c, exint position, int occurance_number=1) const
void append(const char *data, exint size)
const char * lastChar(char c, int occurance_number=1) const
unsigned long long uint64
SYS_FORCE_INLINE char last() const
utf16 * lockUTF16(exint offset=0, exint len=0)
Lock buffer for len utf-16 characters.
SYS_FORCE_INLINE void relock()
If you've manually released the lock, you can relock the buffer.
void removePrefix(exint n)
SYS_FORCE_INLINE void append(const UT_String &str)
SYS_FORCE_INLINE const char * data() const
void swap(UT_WorkBuffer &other)
void eraseHead(exint n)
Remove the first n characters.
SYS_FORCE_INLINE void append(const UT_WorkBuffer &wb)
GLubyte GLubyte GLubyte GLubyte w
SYS_FORCE_INLINE bool operator==(const UT_WorkBuffer &buf) const
std::ostream & operator<<(std::ostream &ostr, const DataType &a)
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const UT_WorkBuffer &wb)
SYS_FORCE_INLINE void append(const char *str)
A utility class to do read-only operations on a subset of an existing string.
static const utf8 * convert(const utf8 *str, utf32 &cp)
size_t appendFormat(const char *fmt, const Args &...args)
#define UT_INITIAL_BUFFER_SIZE
SYS_FORCE_INLINE void strcpy(const UT_WorkBuffer &src)
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
SYS_FORCE_INLINE const char * buffer() const
SYS_FORCE_INLINE const char * end() const
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
SYS_FORCE_INLINE UT_WorkBuffer & operator=(const UT_WorkBuffer &other)
void printMemory(int64 mem)
#define SYS_PRINTF_CHECK_ATTRIBUTE(string_index, first_to_check)
SYS_FORCE_INLINE const char * begin() const
Iterator compatibility.
GLsizei const GLchar *const * string
SYS_FORCE_INLINE void prepend(const UT_StringRef &str)
void prepend(char character)
SYS_FORCE_INLINE bool isEmpty() const
SYS_FORCE_INLINE char * strdup() const
static SYS_FORCE_INLINE UT_WorkBuffer widen(const utf8 *str)
SYS_FORCE_INLINE const char * findChar(char c, int occurance_number=1) const
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const UT_String &str)
SYS_FORCE_INLINE exint strlen() const
SYS_FORCE_INLINE bool operator!=(const UT_WorkBuffer &buf) const
SYS_FORCE_INLINE UT_WorkBuffer & operator=(const std::string &str)
SYS_FORCE_INLINE const char * c_str() const
SYS_FORCE_INLINE void strcpy(const UT_String &src)
#define UT_UTF8_MAX_ENCODING_LEN
size_t SYSstrlcpy(char *dest, const char *src, size_t size)
checked_ptr< typename Container::value_type > reserve(std::back_insert_iterator< Container > it, size_t n)
SYS_FORCE_INLINE char * string() const
SYS_FORCE_INLINE void prepend(const UT_String &str)
SYS_FORCE_INLINE char operator()(exint idx) const
SYS_FORCE_INLINE UT_WorkBuffer(const UT_WorkBuffer &other)
SYS_FORCE_INLINE void strcat(const char *src)
detail::named_arg< Char, T > arg(const Char *name, const T &arg)
int substitute(const char *find, const char *replacement, bool all=true)
Convenience version of substitute() for all or single occurrence.
SYS_FORCE_INLINE void truncate(exint new_length)
SYS_FORCE_INLINE const utf16 * castToUTF16() const
Once set as UTF16-LE, get it back as such a pointer.
GLenum GLuint GLenum GLsizei const GLchar * buf
exint entries() const
Alias of size(). size() is preferred.
void append(utf32 cp)
Append a single Unicode code point, converted to UTF8.
SYS_FORCE_INLINE int strcmp(const char *src) const
GLuint GLsizei GLsizei * length
GLint GLint GLsizei GLint GLenum format
static SYS_FORCE_INLINE UT_WorkBuffer narrow(const utf16 *str)
SYS_FORCE_INLINE UT_WorkBuffer & operator=(const char *str)
SYS_FORCE_INLINE bool isstring() const
SYS_FORCE_INLINE void backup(exint by_length)
Rewind by the given length.
void write(exint offset, const char *src)
size_t format(const char *fmt, const Args &...args)
SYS_FORCE_INLINE UT_WorkBuffer(const UT_String &str)
SYS_FORCE_INLINE AutoLock(UT_WorkBuffer &buf)
size_t appendPrint(const T &value, const Args &...args)
SYS_FORCE_INLINE bool operator==(const char *str) const
std::string lower(string_view a)
Return an all-upper case version of a (locale-independent).
void advance(exint by_length)
SYS_FORCE_INLINE bool operator!=(const char *str) const
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const char *str)
SYS_FORCE_INLINE bool UTisstring(const char *s)
SYS_FORCE_INLINE void append(char character)
void prepend(const char *data, exint size)
GLsizei const GLfloat * value
virtual bool readFile(GA_Detail &g, const char *filename, const GA_LoadOptions *opts, UT_StringArray *errors) const
Class which defines an I/O interface to save/load geometry.
**If you just want to fire and args
void append(const UT_StringArray &strs, const UT_StringRef &sep)
SYS_FORCE_INLINE ~UT_WorkBuffer()
SYS_FORCE_INLINE void clear()
SYS_FORCE_INLINE ~AutoLock()
SYS_FORCE_INLINE char first() const
void UTstringPathJoin(UT_WorkBuffer &result)
void write(T &out, bool v)
SYS_FORCE_INLINE bool operator!=(const UT_String &str) const
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const UT_StringRef &str)
bool all(const vbool4 &v)
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const std::string &str)
SYS_FORCE_INLINE void write(exint offset, char c)
SYS_FORCE_INLINE bool isstring() const
SYS_FORCE_INLINE void prepend(const char *str)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
SYS_FORCE_INLINE int strncmp(const char *src, exint n) const
std::basic_string< Char > sprintf(const S &format, const Args &...args)
SYS_FORCE_INLINE UT_WorkBuffer()