22 PFC_ASSERT( base <= m_len );
23 return make(m_ptr + base, m_len - base);
26 PFC_ASSERT( base <= m_len && base + len <= m_len );
27 return make(m_ptr + base, len);
38 virtual void add_string(
const char * p_string,
t_size p_string_size = ~0) = 0;
60 template<
typename char_t>
inline char_t
ascii_tolower(char_t c) {
if (c >=
'A' && c <=
'Z') c +=
'a' -
'A';
return c;}
61 template<
typename char_t>
inline char_t
ascii_toupper(char_t c) {
if (c >=
'a' && c <=
'z') c +=
'A' -
'a';
return c;}
83 template<
typename t_
char>
85 PFC_ASSERT( ptr != NULL || max == 0 );
87 while(n<max && ptr[n] != 0) n++;
99 template<typename char_t> inline
bool char_is_numeric(char_t p_char) throw() {
return p_char >=
'0' && p_char <=
'9';}
118 for(
t_size walk = 0; walk < inLen; ++walk) {
119 if (ret & guard)
throw exception_overflow();
126 for(
t_size walk = 0; walk < inLen; ++walk) {
129 if ((ret / 10) != prev)
throw exception_overflow();
141 template<typename char_t>
void strcpy_t( char_t * out, const char_t * in ) {
142 for(;;) { char_t c = *in++; *out++ = c;
if (c == 0)
break; }
174 int strcmp_nc(const
char* p1,
size_t n1, const
char * p2,
size_t n2) throw();
195 virtual const char * get_ptr()
const = 0;
196 virtual void add_string(
const char * p_string,
t_size p_length = ~0) = 0;
197 virtual void set_string(
const char * p_string,
t_size p_length = ~0) {reset();add_string(p_string,p_length);}
198 virtual void truncate(
t_size len)=0;
200 virtual char * lock_buffer(
t_size p_requested_length) = 0;
201 virtual void unlock_buffer() = 0;
205 inline const char *
toString()
const {
return get_ptr();}
212 inline bool is_empty()
const {
return *get_ptr()==0;}
214 void skip_trailing_char(
unsigned c =
' ');
220 inline const string_base & operator= (
const char * src) {set_string_(src);
return *
this;}
221 inline const string_base & operator+= (
const char * src) {add_string_(src);
return *
this;}
232 inline operator const char * ()
const {
return get_ptr();}
241 void fix_dir_separator(
char c =
'\\');
242 void end_with(
char c);
243 void end_with_slash();
244 bool ends_with(
char c)
const;
245 void delimit(
const char* c) {
if (length()>0) add_string(c);}
246 char last_char()
const;
247 void truncate_last_char();
248 void truncate_number_suffix();
250 bool truncate_eol(
t_size start = 0);
251 bool fix_eol(
const char * append =
" (...)",
t_size start = 0);
252 bool limit_length(
t_size length_in_chars,
const char * append =
" (...)");
255 void truncate_to_parent_path();
258 t_size replace_string (
const char * replace,
const char * replaceWith,
t_size start = 0);
271 template<t_size max_length>
282 if (p_requested_length >= max_length)
return NULL;
290 inline operator const char * ()
const {
return m_data;}
296 if (
m_length + len < m_length || m_length + len > max_length)
throw pfc::exception_overflow();
297 for(
t_size n=0;n<len;n++) {
303 if (len > max_length) len = max_length;
312 PFC_STATIC_ASSERT(max_length>1);
319 template<
template<
typename>
class t_alloc>
328 if (t_alloc<char>::alloc_prioritizes_speed) {
334 else if (old_size > s + 32)
339 inline const char *
_get_ptr()
const throw() {
return used > 0 ? m_data.
get_ptr() :
"";}
345 PFC_ASSERT(! m_data.
is_owned(ptr) );
353 PFC_ASSERT(! m_data.
is_owned(ptr) );
370 inline operator const char * ()
const throw() {
return _get_ptr();}
391 if (used>len) {used=len;m_data[len]=0;
makespace(used+1);}
397 void set_char(
unsigned offset,
char c);
410 if (n + 1 == 0)
throw exception_overflow();
425 inline static void g_swap(t_self & p_item1,t_self & p_item2) {
450 #define PFC_DEPRECATE_PRINTF PFC_DEPRECATE("Use string8/string_fixed_t with operator<< overloads instead.")
467 static void g_run(
string_base & out,
const char * fmt,va_list list);
468 void run(
const char * fmt,va_list list);
516 inline operator const char * ()
const {
return buffer;}
526 inline operator const char*()
const {
return m_data;}
535 inline operator const char*()
const {
return m_data;}
540 void float_to_string(
char * out,
t_size out_max,
double val,
unsigned precision,
bool force_sign =
false);
552 format_float(
double p_val,
unsigned p_width = 0,
unsigned p_prec = 7);
569 inline operator const char*()
const {
return m_buffer;}
581 inline operator const char*()
const {
return m_buffer;}
593 inline operator const char*()
const {
return m_buffer;}
604 inline operator const char*()
const {
return m_buffer;}
615 #define PFC_string_formatter() ::pfc::string_formatter()._formatter()
647 inline operator const char*()
const {
return m_buffer;}
657 inline operator const char*()
const {
return m_buffer;}
663 template<
typename t_
stringbuffer = pfc::
string8_fastalloc>
667 t_size source_len = 0, source_walk = 0;
669 while(source_walk < p_string_length && source_len < p_chars) {
672 if (delta == 0)
break;
674 source_walk += delta;
677 m_buffer.add_string(p_string,source_walk);
678 m_buffer.add_chars(p_padding,p_chars - source_len);
681 inline operator const char*()
const {
return m_buffer;}
687 template<
typename t_
stringbuffer = pfc::
string8_fastalloc>
691 t_size source_len = 0, source_walk = 0;
693 while(source_walk < p_string_length && source_len < p_chars) {
696 if (delta == 0)
break;
698 source_walk += delta;
701 m_buffer.add_chars(p_padding,p_chars - source_len);
702 m_buffer.add_string(p_string,source_walk);
705 inline operator const char*()
const {
return m_buffer;}
745 template<
typename t_source>
format_array(t_source
const & source,
const char * separator =
", ") {
749 for(
t_size walk = 1; walk < count; ++walk) *
this << separator << source[walk];
758 for(
t_size n = 0; n < bufLen; n++) {
759 if (n > 0 && spacing != NULL)
m_formatter << spacing;
774 template<
typename t_
char>
781 if (s == 0)
return 0;
else return s-1;
818 operator const t_char* ()
const {
return get_ptr();}
833 inline static int compare(
const char * p_item1,
const char * p_item2) {
return strcmp(p_item1,p_item2);}
834 inline static int compare(
const wchar_t * item1,
const wchar_t * item2) {
return wcscmp(item1, item2);}
860 for(
typename t_source::const_iterator walk = in.first(); walk.is_valid(); ++walk) {
862 if (walk == in.last()) out << separatorLast;
863 else out << separator;
869 template<
typename t_output,
typename t_splitCheck>
870 void splitStringEx(t_output & p_output,
const t_splitCheck & p_check,
const char * p_string,
t_size p_stringLen = ~0) {
871 t_size walk = 0, splitBase = 0;
874 t_size delta = p_check(p_string + walk,max - walk);
876 if (walk > splitBase) p_output(p_string + splitBase, walk - splitBase);
877 splitBase = walk + delta;
880 if (delta == 0)
break;
884 if (walk > splitBase) p_output(p_string + splitBase, walk - splitBase);
902 for(
t_size walk = 0, ptr = 0; walk < m_chars.get_size(); ++walk) {
910 for(
t_size walk = 0; walk < m_chars.get_size(); ++walk) {
911 if (m_chars[walk] == c)
return delta;
923 PFC_ASSERT( len > 0 );
924 if (*str == m_char)
return 1;
930 template<
typename t_array>
941 template<
typename t_list>
952 template<
typename t_array,
typename t_split>
959 p_output.set_size(wrapper.
get());
967 template<
typename t_list,
typename t_split>
977 const char * next = strchr(str,
'\n');
981 const char * walk = next;
982 while(walk > str && walk[-1] ==
'\r') --walk;
989 const char * next = strchr(str, c);
999 const char * next = strstr(str, split);
1004 str = next + strlen(split);
1018 template<
typename T>
inline const char *
stringToPtr(
T const& val) {
return val.get_ptr();}
1019 template<>
inline const char *
stringToPtr(std::string
const& val) {
return val.c_str();}
1035 void add_string(
const char * p_string,
t_size p_length = ~0) {
throw pfc::exception_not_implemented();}
1036 void set_string(
const char * p_string,
t_size p_length = ~0) {
throw pfc::exception_not_implemented();}
1046 template<
typename TChar, t_size len,
typename TSource>
1048 PFC_STATIC_ASSERT(len>0);
1050 for(walk = 0; walk < len - 1 && source[walk] != 0; ++walk) {
1051 buffer[walk] = source[walk];
1057 template<
typename TChar, t_size len,
typename TSource>
1060 for(walk = 0; source[walk] != 0; ++walk) {
1061 if (walk >= len)
throw exception_overflow();
1062 buffer[walk] = source[walk];
1064 if (walk >= len)
throw exception_overflow();
1070 for(
t_size walk=0;walk<p_substring_length;walk++) {
1071 t_char stringchar = (walk>=p_string_length ? 0 : p_string[walk]);
1072 t_char substringchar = p_substring[walk];
1073 int result =
compare_t(stringchar,substringchar);
1074 if (result != 0)
return result;
1080 p_string_length =
strlen_max_t(p_string,p_string_length); p_substring_length =
strlen_max_t(p_substring,p_substring_length);
1084 template<
typename t_
char>
1098 #endif //_PFC_STRING_H_
array_t< t_uint32 > m_chars
char * lock_buffer(t_size p_requested_length)
void set_string_nc(const t_char *p_source, t_size p_length)
t_size utf16_encode_char(unsigned c, char16_t *out)
string_part_ref substring(t_size base) const
char ascii_tolower_lookup(char c)
t_size skip_utf8_chars(const char *ptr, t_size count)
bool stringEqualsI_ascii(const char *p1, const char *p2)
char format_hex_char_lowercase(unsigned p_val)
void set_string_nc(const char *ptr, t_size len)
void set_string(const t_char *p_source, t_size p_length)
virtual t_size get_length() const
bool operator==(const string_base &p_other) const
void set_string(const char *p_string, t_size p_length=~0)
bool string_has_suffix(const char *string, const char *suffix)
const t_item * get_ptr() const
t_size get_length() const
void fix_filename_chars(char def= '_', char leave=0)
const char * stringToPtr(T const &val)
t_size find_last(char p_char, t_size p_start=~0) const
t_size strstr_ex(const char *p_string, t_size p_string_len, const char *p_substring, t_size p_substring_len)
bool has_prefix(const char *prefix) const
string_part_ref substring(t_size base, t_size len) const
string_fixed_t(const char *p_source)
virtual void unlock_buffer()=0
_splitStringSimple_check(const char *p_chars)
void add_chars(t_uint32 p_char, t_size p_count)
unsigned char_to_hex(char c)
void splitStringByLines(t_out &out, const char *str)
void set_string(string_part_ref ref)
int strcmp_partial_ex_t(const t_char *p_string, t_size p_string_length, const t_char *p_substring, t_size p_substring_length)
const t_self & operator=(const t_char *p_source)
bool stringEqualsI_utf8(const char *p1, const char *p2)
t_size strcpy_utf8_truncate(const char *src, char *out, t_size maxbytes)
bool is_path_separator(unsigned c)
virtual void add_string(const char *p_string, t_size p_length=~0)=0
void splitStringByChar(t_out &out, const char *str, char c)
void recover_invalid_utf8(const char *src, char *out, unsigned replace)
void truncate(t_size len)
static int compare(const char *p_item1, const char *p_item2)
pfc::array_t< char, t_alloc > m_data
void splitStringSimple_toArray(t_array &p_output, t_split p_split, const char *p_string, t_size p_stringLen=~0)
string_simple_t(const t_char *p_source)
double string_to_float(const char *src, t_size max)
void truncate(t_size len)
bool operator>=(const string_base &p_other) const
t_uint atohex(const char *in, t_size inLen)
bool string_is_numeric(const char *p_string, t_size p_length)
pfc::string_base & operator<<(pfc::string_base &p_fmt, const char *p_source)
string_simple_t(const t_char *p_source, t_size p_length)
void add_string_(const char *str)
void add_string_nc(const char *ptr, t_size len)
void delimit(const char *c)
bool char_is_ascii_alpha(char p_char)
t_size utf8_encode_char(unsigned c, char *out)
const char * utf8_char_next(const char *src)
void splitStringEx(t_output &p_output, const t_splitCheck &p_check, const char *p_string, t_size p_stringLen=~0)
string_filename(const char *fn)
int _strcmp_partial_ex(const t_char *p_string, t_size p_string_length, const t_char *p_substring, t_size p_substring_length)
_splitStringSimple_check(char c)
t_size replace_char(unsigned c1, unsigned c2, t_size start=0)
int stricmp_ascii_ex(const char *const s1, t_size const len1, const char *const s2, t_size const len2)
t_size get_length() const
bool operator!=(const string_base &p_other) const
void set_char(unsigned offset, char c)
bool is_multiline(const char *p_string, t_size p_len)
string_base_ref(const char *ptr)
t_size wide_decode_char(const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0)
static int compare(string_part_ref p_item1, const char *p_item2)
bool string_has_suffix_i(const char *string, const char *suffix)
int strcmp_partial_ex(const char *str, t_size strLen, const char *substr, t_size substrLen)
t_size scan_filename() const
void strcpy_t(char_t *out, const char_t *in)
char_t ascii_toupper(char_t c)
t_size operator()(const char *p_string, t_size p_stringLen) const
int stringCompareCaseInsensitiveEx(string_part_ref s1, string_part_ref s2)
string_buffer(string_base &p_string, t_size p_requested_length)
void remove_chars(t_size first, t_size count)
string8_t< pfc::alloc_standard > string8
int naturalSortCompare(const char *s1, const char *s2)
void add_string(string_part_ref ref)
void prealloc(t_size p_size)
bool has_suffix_i(const char *suffix) const
static void g_swap(t_self &p_item1, t_self &p_item2)
t_size find_first(const char *p_string, t_size p_start=0) const
unsigned utf8_get_char(const char *src)
char_t ascii_tolower(char_t c)
void operator()(const char *, t_size)
t_size operator()(const char *str, t_size len) const
const char * _get_ptr() const
static int compare(const char *i1, const char *i2)
t_uint atodec(const char *in, t_size inLen)
__splitStringSimple_calculateSubstringCount()
t_size utf8_char_len_from_header(char c)
bool char_is_hexnumeric(char p_char)
bool has_prefix_i(const char *prefix) const
void urlEncode(pfc::string_base &out, const char *in)
bool utf8_advance(const char *&var)
int strcmp_ex(const char *p1, t_size n1, const char *p2, t_size n2)
pfc::array_t< t_char > m_buffer
void truncate(t_size len)
t_size string_find_first_ex(const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
int stricmp_ascii_partial(const char *str, const char *substr)
const char * get_ptr() const
bool is_valid_utf8() const
t_size string_find_first_nc(const char *p_string, t_size p_string_length, char c, t_size p_start)
t_size strlen_utf8(const char *s, t_size num=~0)
void add_string(const char *p_string, t_size p_length=~0)
void add_string(const char *ptr, t_size len)
void stringToLowerAppend(string_base &out, const char *src, t_size len)
string_simple_t< char > string_simple
bool operator<=(const string_base &p_other) const
string_extension(const char *src)
t_size strlen_max(const char *ptr, t_size max)
string8_t(const char *p_string, t_size p_length)
t_size strlen_t(const t_char *p_string, t_size p_length=~0)
string8_fastalloc string_formatter
void stringToBufferGuarded(TChar(&buffer)[len], const TSource &source)
Same as stringToBuffer() but throws exception_overflow() if the string could not be fully written...
string_replace_extension(const char *p_path, const char *p_ext)
static void stringCombine(pfc::string_base &out, t_source const &in, const char *separator, const char *separatorLast)
double parse_timecode(const char *in)
void set_size(t_size p_size)
string_base & _formatter() const
__splitStringSimple_arrayWrapper(t_array &p_array)
int strcmp_partial_t(const t_char *p_string, const t_char *p_substring)
int strcmp_nc(const char *p1, size_t n1, const char *p2, size_t n2)
string_fixed_t(const string_fixed_t< max_length > &p_source)
t_uint64 atoui64_ex(const char *src, t_size len)
virtual char * lock_buffer(t_size p_requested_length)=0
void prealloc(t_size p_size)
void urlEncodeAppendRaw(pfc::string_base &out, const char *in, t_size inSize)
static string_part_ref make(const char *ptr, t_size len)
void set_string_(const char *str)
t_size scan_filename(const char *ptr)
void set_string_(const char *str)
int compare_t(const hasher_md5_result &p_item1, const hasher_md5_result &p_item2)
char * strdup_n(const char *src, t_size len)
virtual void set_string(const char *p_string, t_size p_length=~0)
void stringToUpperAppend(string_base &out, const char *src, t_size len)
t_size strlen_max_t(const t_char *ptr, t_size max)
void set_string(const t_char *p_source)
void operator()(const char *p_string, t_size p_stringLen)
char m_data[max_length+1]
string8_t< t_alloc > t_self
void splitStringBySubstring(t_out &out, const char *str, const char *split)
const char * get_ptr() const
unsigned atoui_ex(const char *p_string, t_size p_string_len)
const string_fixed_t< max_length > & operator=(const char *p_source)
string8_t(const string_base &p_string)
static int compare(const wchar_t *item1, const wchar_t *item2)
t_int64 atoi64_ex(const char *src, t_size len)
string8_t(const t_self &p_string)
bool string_has_prefix_i(const char *string, const char *prefix)
t_size utf16_decode_char(const char16_t *p_source, unsigned *p_out, t_size p_source_length=~0)
t_size string_find_last_ex(const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
t_size utf8_decode_char(const char *src, unsigned &out, t_size src_bytes)
char * lock_buffer(t_size n)
bool string_has_prefix(const char *string, const char *prefix)
void urlEncodeAppend(pfc::string_base &out, const char *in)
uint32_t charLower(uint32_t param)
void add_string(const char *p_string, t_size p_length=~0)
static int compare(const char *p_item1, string_part_ref p_item2)
void add_string_nc(const t_char *p_source, t_size p_length)
int naturalSortCompareI(const char *s1, const char *s2)
bool operator>(const string_base &p_other) const
string8_t(string_part_ref ref)
void float_to_string(char *out, t_size out_max, double val, unsigned precision, bool b_sign)
bool is_valid_utf8(const char *param, t_size max=~0)
char * lock_buffer(t_size p_requested_length)
void insert_chars(t_size first, const char *src, t_size count)
void stringToBuffer(TChar(&buffer)[len], const TSource &source)
Writes a string to a fixed-size buffer. Truncates the string if necessary. Always writes a null termi...
const char * toString() const
t_size _strParamLen(const char *str)
uint32_t charUpper(uint32_t param)
void set_string(const char *p_string, t_size p_length=~0)
t_size string_find_last(const char *p_string, char p_tofind, t_size p_start)
bool has_suffix(const char *suffix) const
int strcmp_partial(const char *str, const char *substr)
t_size array_size_t(const t_array &p_array)
const t_self & operator+=(const char *src)
t_size wide_encode_char(unsigned c, wchar_t *out)
int stringCompareCaseInsensitive(const char *s1, const char *s2)
string8_t< pfc::alloc_fast > string8_fast
string_part_ref string_part(const char *ptr, t_size len)
unsigned char_to_dec(char c)
void splitStringSimple_toList(t_list &p_output, t_split p_split, const char *p_string, t_size p_stringLen=~0)
int stricmp_ascii(const char *s1, const char *s2)
void add_string(const t_char *p_source)
static int compare(string_part_ref p_item1, string_part_ref p_item2)
bool char_is_numeric(char_t p_char)
bool char_is_ascii_alpha_lower(char p_char)
const string_fixed_t< max_length > & operator=(const string_fixed_t< max_length > &p_source)
bool char_is_ascii_alpha_upper(char p_char)
const char * get_ptr() const
t_size utf8_chars_to_bytes(const char *string, t_size count)
bool is_path_bad_char(unsigned c)
void memcpy_t(t_dst *p_dst, const t_src *p_src, t_size p_count)
bool operator<(const string_base &p_other) const
t_size string_find_first(const char *p_string, char p_tofind, t_size p_start)
void operator()(const char *p_string, t_size p_stringLen)
char format_hex_char(unsigned p_val)
void swap_t(T &p_item1, T &p_item2)
t_size replace_nontext_chars(char p_replace= '_')
const t_self & operator=(const char *src)
bool char_is_ascii_alphanumeric(char p_char)
void add_string_(const char *str)
__splitStringSimple_listWrapper(t_list &p_list)
void memset_t(T *p_buffer, const t_val &p_val, t_size p_count)
void add_string(const t_char *p_source, t_size p_length)
bool has_path_bad_chars(const char *param)
string_filename_ext(const char *fn)
t_size utf8_char_len(const char *s, t_size max=~0)
static int compare(const char *p_item1, const char *p_item2)
bool is_lower_ascii(const char *param)
string8_t(const char *p_string)
void convert_to_lower_ascii(const char *src, t_size max, char *out, char replace)
t_size find_last(const char *p_string, t_size p_start=~0) const
string_directory(const char *p_path)
t_size find_first(char p_char, t_size p_start=0) const
string8_t< pfc::alloc_fast_aggressive > string8_fastalloc
const char * get_ptr() const
t_size tcslen_max(const TCHAR *ptr, t_size max)
static string_part_ref stringToRef(T const &val)
const t_char * get_ptr() const
t_size replace_byte(char c1, char c2, t_size start=0)
void add_filename(const char *fn)
t_size wcslen_max(const wchar_t *ptr, t_size max)
t_size length() const
For compatibility with old conventions.
const char * toString() const
t_size get_length() const
string_simple_t< t_char > t_self
string8_t< pfc::alloc_fast_aggressive > string8_fast_aggressive
bool is_owned(const t_source &p_item)