26 #ifndef __UT_WorkBuffer_h__
27 #define __UT_WorkBuffer_h__
54 #define UT_INITIAL_BUFFER_SIZE 2000
66 : myBuffer(myStackBuffer)
74 : myBuffer(myStackBuffer)
82 : myBuffer(myStackBuffer)
90 : myBuffer(myStackBuffer)
98 : myBuffer(myStackBuffer)
106 : myBuffer(myStackBuffer)
115 if (myBuffer != myStackBuffer)
147 const char *
buffer()
const {
return myBuffer; }
171 void release(
bool recompute_length =
false);
172 void releaseSetLength(
exint new_length);
176 int64 getMemoryUsage(
bool inclusive)
const;
189 myString = myBuffer.lock();
202 char *
string()
const {
return myString; }
211 myBuffer.release(recompute_length);
220 myString = myBuffer.lock();
239 return myBuffer[idx];
254 return myBuffer[myLength - 1];
258 int isNullTerminated()
const;
277 append(str.c_str(), str.length());
288 return (::strcmp(str, myBuffer) == 0);
293 if (!(
const char *)str)
295 return (::strcmp(str, myBuffer) == 0);
304 return (::memcmp(myBuffer, buf.myBuffer, myLength) == 0);
309 return !(*
this == str);
314 return !(*
this == str);
319 return !(*
this ==
buf);
326 void growBufferIfNeeded()
332 while (myLength+1 > myAllocatedSize)
370 growBufferIfNeeded();
373 myLength = ::strlen(myBuffer);
381 return ::strlen(myBuffer);
399 void protectedStrcat(
const char *str,
bool force_quote=
false);
409 void fullyProtectedStrcat(
const char *str,
bool force_quote=
false);
410 void fullyProtectedBinaryStrcat(
411 const char *str,
exint size,
bool force_quote=
false);
421 append(src, ::strnlen(src, len));
427 void strcatFirstWord(
const char *
src);
433 return ::strcmp(myBuffer, src);
440 return ::strncmp(myBuffer, src, n);
447 return ::strdup(myBuffer);
454 if (myLockCount) {
UT_ASSERT(0);
return; }
462 return (myLength == 0);
477 if (offset < 0)
return;
478 if (offset >= myLength)
480 if (myLockCount) {
UT_ASSERT(0);
return; }
482 growBufferIfNeeded();
483 myBuffer[myLength] =
'\0';
513 bool getline(std::istream &is);
514 bool getline(FILE *fp);
523 const char *comment_chars =
"#",
524 const char *separators =
" \t\n\r");
526 const char *comment_chars =
"#",
527 const char *separators =
" \t\n\r");
529 const char *comment_chars =
"#",
530 const char *separators =
" \t\n\r");
532 int sprintf(
const char *fmt, ...)
534 int appendSprintf(
const char *fmt, ...)
542 template<typename... Args>
546 return appendFormat(fmt, args...);
551 template<
typename... Args>
554 if (myLockCount) {
UT_ASSERT(0);
return 0; }
560 size_t nb_needed =
f.format(
w, fmt, {args...});
562 myLength += nb_needed;
563 growBufferIfNeeded();
566 w.setBuffer(myBuffer + myLength - nb_needed, nb_needed);
567 f.format(
w, fmt, {args...});
569 myBuffer[myLength] =
'\0';
576 template<
typename... Args>
580 return appendPrint(args...);
586 template<
typename... Args>
591 template<
typename T,
typename... Args>
595 newbytes = appendFormat(
"{}", value);
601 newbytes += appendPrint(args...);
609 if (myLockCount) {
UT_ASSERT(0);
return; }
612 growBufferIfNeeded();
613 myBuffer[myLength - 1] = character;
614 myBuffer[myLength] =
'\0';
618 void appendPrintMemory(
int64 mem);
622 if (myLockCount) {
UT_ASSERT(0);
return; }
625 growBufferIfNeeded();
626 for (
int i = n; i > 0; i--)
627 myBuffer[myLength - i] = character;
628 myBuffer[myLength] =
'\0';
639 if (myLockCount) {
UT_ASSERT(0);
return; }
642 growBufferIfNeeded();
643 ::memcpy(myBuffer + myLength - len, buf, len);
644 myBuffer[myLength] =
'\0';
649 if (myLockCount) {
UT_ASSERT(0);
return; }
653 growBufferIfNeeded();
654 ::memcpy(myBuffer + myLength - size, data, size);
655 myBuffer[myLength] =
'\0';
662 append(str, ::strlen(str));
669 append((
const char *)str);
732 if (myLockCount) {
UT_ASSERT(0);
return; }
735 growBufferIfNeeded();
736 ::memmove(myBuffer+1, myBuffer, myLength);
737 myBuffer[0] = character;
741 if (myLockCount) {
UT_ASSERT(0);
return; }
745 growBufferIfNeeded();
746 ::memmove(myBuffer+size, myBuffer, myLength+1 - size);
747 ::memcpy(myBuffer, data, size);
753 prepend(str, ::strlen(str));
760 prepend((
const char *)str);
782 if (myLockCount) {
UT_ASSERT(0);
return; }
785 myLength -= by_length;
787 myBuffer[myLength] =
'\0';
795 if (new_length >= myLength)
797 UT_ASSERT(0 &&
"Truncating beyond buffer extent");
800 backup(myLength-new_length);
807 if (myLockCount) {
UT_ASSERT(0);
return; }
809 while( myLength > 0 && myBuffer[myLength-1] != c )
811 myBuffer[myLength] =
'\0';
816 if (myLockCount) {
UT_ASSERT(0);
return; }
819 myLength -= by_length;
821 for (
int i=0; i<myLength; i++)
822 myBuffer[i] = myBuffer[by_length+i];
823 myBuffer[myLength] =
'\0';
828 const char *
findChar(
char c,
int occurance_number = 1)
const
830 return findCharFrom(c, 0, occurance_number);
833 const char *
lastChar(
char c,
int occurance_number = 1)
const
835 if (myLockCount) {
UT_ASSERT(0);
return NULL; }
839 for (
exint i = myLength; i --> 0;)
844 if(occurance_number <= 0)
846 return (myBuffer + i);
855 int occurance_number = 1)
const
857 if (myLockCount) {
UT_ASSERT(0);
return NULL; }
861 if (position < 0 || position >= myLength) {
return NULL; }
863 for(
exint i = position; i < myLength; ++i)
868 if(occurance_number <= 0)
870 return (myBuffer + i);
884 bool getNextToken(
const char *(&
string),
888 void copyIntoString(
UT_String &str)
const;
892 void copyIntoString(
char *str,
exint max_length)
const;
911 bool stripComments(
char comment_char =
'#');
916 int strip(
const char *chars);
919 void removeTrailingSpaceLines();
922 bool removeTrailingSpace();
925 bool removeLeadingSpace();
928 bool removeTrailingDigits();
937 void makeIndentString(
exint indent,
exint tabstop=8);
945 ::memmove(myBuffer, myBuffer + n, myLength);
950 myBuffer[myLength] =
'\0';
955 unsigned int substitute(
const char *
find,
const char *replacement,
bool all =
true);
967 const char *to_pattern,
968 const char *from_name,
969 const char *from_pattern);
977 void setFromUTF16(
const utf16 *str);
982 void setAsUTF16(
const utf8 *str);
999 bool this_stack = (myBuffer == myStackBuffer);
1000 bool other_stack = (other.myBuffer == other.myStackBuffer);
1002 if (this_stack && other_stack)
1006 size_t max_size = (myLength > other.myLength) ? myLength
1009 UTswap(myStackBuffer, other.myStackBuffer, max_size + 1);
1011 else if (this_stack && !other_stack)
1013 ::memcpy(other.myStackBuffer, myStackBuffer, myLength + 1);
1014 myBuffer = other.myBuffer;
1015 other.myBuffer = other.myStackBuffer;
1017 else if (!this_stack && other_stack)
1019 ::memcpy(myStackBuffer, other.myStackBuffer, other.myLength + 1);
1020 other.myBuffer = myBuffer;
1021 myBuffer = myStackBuffer;
1024 UTswap(myBuffer, other.myBuffer);
1025 UTswap(myAllocatedSize, other.myAllocatedSize);
1026 UTswap(myLength, other.myLength);
1027 UTswap(myLockCount, other.myLockCount);
1032 const char *
begin()
const {
return myBuffer; }
1034 const char *
end()
const {
return myBuffer + myLength; }
1039 struct do_narrow {};
1044 : myBuffer(myStackBuffer)
1053 : myBuffer(myStackBuffer)
1070 int myLockCount = 0;
1075 static inline size_t
size_t print(const Args &...args)
vbool4 insert(const vbool4 &a, bool val)
Helper: substitute val for a[i].
std::string sprintf(const char *fmt, const Args &...args)
SYS_FORCE_INLINE void append(const UT_StringRef &str)
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
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.
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
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
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.
SYS_FORCE_INLINE void append(const UT_String &str)
void swap(UT_WorkBuffer &other)
void eraseHead(exint n)
Remove the first n characters.
SYS_FORCE_INLINE void append(const UT_WorkBuffer &wb)
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)
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)
SYS_FORCE_INLINE const char * buffer() const
std::enable_if< is_contiguous< Container >::value, typename checked< typename Container::value_type >::type >::type reserve(std::back_insert_iterator< Container > &it, std::size_t n)
SYS_FORCE_INLINE const char * end() const
GLint GLenum GLsizei GLint GLsizei const void * data
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.
GLubyte GLubyte GLubyte GLubyte w
GLuint GLsizei GLsizei * length
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)
std::string toStdString() const
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)
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.
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
static SYS_FORCE_INLINE UT_WorkBuffer narrow(const utf16 *str)
SYS_FORCE_INLINE UT_WorkBuffer & operator=(const char *str)
GLsizei const GLchar *const * string
std::basic_string< Char > vsprintf(const S &format, basic_format_args< typename basic_printf_context_t< internal::basic_buffer< Char >>::type > args)
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)
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
SYS_FORCE_INLINE bool UTisstring(const char *s)
void advance(exint by_length)
SYS_FORCE_INLINE bool operator!=(const char *str) const
SYS_FORCE_INLINE UT_WorkBuffer & operator+=(const char *str)
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
SYS_FORCE_INLINE void append(char character)
GLuint GLuint GLsizei count
void prepend(const char *data, exint size)
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.
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
vint4 min(const vint4 &a, const vint4 &b)
void write(T &out, bool v)
GLenum GLuint GLsizei const GLchar * buf
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)
GLsizei const GLfloat * value
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
SYS_FORCE_INLINE UT_WorkBuffer()