Data Structures
class	char_buffer_t

class	string_ansi_from_utf8

class	string_ansi_from_wide

class	string_ascii_from_utf8

class	string_codepage_from_utf8

class	string_codepage_from_wide_t

class	string_utf8_from_ansi

class	string_utf8_from_codepage

class	string_utf8_from_os_ex

class	string_utf8_from_wide_t

class	string_utf8_from_win1252_t

class	string_wide_from_ansi

class	string_wide_from_codepage_t

class	string_wide_from_utf8_t

class	string_wide_from_win1252_t

class	string_win1252_from_utf8_t

class	string_win1252_from_wide_t

Typedefs
typedef string_win1252_from_utf8	string_ansi_from_utf8

typedef string_win1252_from_wide	string_ansi_from_wide

typedef string_codepage_from_wide_t	string_codepage_from_wide

typedef string_wide_from_utf8	string_os_from_utf8

typedef string_wide_from_utf8_fast	string_os_from_utf8_fast

typedef string_utf8_from_win1252	string_utf8_from_ansi

typedef string_utf8_from_wide	string_utf8_from_os

typedef string_utf8_from_wide_t	string_utf8_from_wide

typedef string_utf8_from_win1252_t	string_utf8_from_win1252

typedef string_wide_from_win1252	string_wide_from_ansi

typedef string_wide_from_codepage_t	string_wide_from_codepage

typedef string_wide_from_utf8_t	string_wide_from_utf8

typedef string_wide_from_utf8_t< alloc_fast_aggressive >	string_wide_from_utf8_fast

typedef string_wide_from_win1252_t	string_wide_from_win1252

typedef string_win1252_from_utf8_t	string_win1252_from_utf8

typedef string_win1252_from_wide_t	string_win1252_from_wide

Enumerations
enum	{ codepage_system = CP_ACP, codepage_ascii = 20127, codepage_iso_8859_1 = 28591 }

Functions
char	charToASCII (unsigned c)

t_size	convert_ansi_to_wide (wchar_t p_out, t_size p_out_size, const char p_source, t_size p_source_size)

t_size	convert_codepage_to_wide (unsigned p_codepage, wchar_t p_out, t_size p_out_size, const char p_source, t_size p_source_size)

t_size	convert_utf8_to_ascii (char p_out, t_size p_out_size, const char p_in, t_size p_in_size)

t_size	convert_utf8_to_wide (wchar_t p_out, t_size p_out_size, const char p_source, t_size p_source_size)

t_size	convert_utf8_to_wide_unchecked (wchar_t p_out, const char p_in)

t_size	convert_utf8_to_win1252 (char p_out, t_size p_out_size, const char p_in, t_size p_in_size)

t_size	convert_wide_to_ansi (char p_out, t_size p_out_size, const wchar_t p_source, t_size p_source_size)

t_size	convert_wide_to_codepage (unsigned p_codepage, char p_out, t_size p_out_size, const wchar_t p_source, t_size p_source_size)

t_size	convert_wide_to_utf8 (char p_out, t_size p_out_size, const wchar_t p_source, t_size p_source_size)

t_size	convert_wide_to_win1252 (char p_out, t_size p_out_size, const wchar_t p_in, t_size p_in_size)

t_size	convert_win1252_to_utf8 (char p_out, t_size p_out_size, const char p_in, t_size p_in_size)

t_size	convert_win1252_to_wide (wchar_t p_out, t_size p_out_size, const char p_in, t_size p_in_size)

t_size	estimate_ansi_to_wide (const char *p_source, t_size p_source_size)

t_size	estimate_codepage_to_wide (unsigned p_codepage, const char *p_source, t_size p_source_size)

t_size	estimate_utf8_to_ascii (const char *p_source, t_size p_source_size)

t_size	estimate_utf8_to_wide (const char *p_in)

t_size	estimate_utf8_to_wide (const char *p_source, t_size p_source_size)

t_size	estimate_utf8_to_wide_quick (t_size sourceLen)

t_size	estimate_utf8_to_wide_quick (const char *source)

t_size	estimate_utf8_to_wide_quick (const char *source, t_size sourceLen)

t_size	estimate_utf8_to_win1252 (const char *p_in, t_size p_in_size)

t_size	estimate_wide_to_ansi (const wchar_t *p_source, t_size p_source_size)

t_size	estimate_wide_to_codepage (unsigned p_codepage, const wchar_t *p_source, t_size p_source_size)

t_size	estimate_wide_to_utf8 (const wchar_t *p_source, t_size p_source_size)

t_size	estimate_wide_to_win1252 (const wchar_t *p_in, t_size p_in_size)

t_size	estimate_win1252_to_utf8 (const char *p_in, t_size p_in_size)

t_size	estimate_win1252_to_wide (const char *p_source, t_size p_source_size)

template<typename t_char >
const t_char *	null_string_t ()

template<>
const char *	null_string_t< char > ()

template<>
const wchar_t *	null_string_t< wchar_t > ()

template<typename t_char >
bool	string_is_empty_t (const t_char *p_string, t_size p_string_size=~0)

template<typename t_char >
t_size	strlen_t (const t_char *p_string, t_size p_string_size=~0)

Typedef Documentation

typedef string_win1252_from_utf8 pfc::stringcvt::string_ansi_from_utf8

Definition at line 552 of file string_conv.h.

typedef string_win1252_from_wide pfc::stringcvt::string_ansi_from_wide

Definition at line 550 of file string_conv.h.

typedef string_codepage_from_wide_t pfc::stringcvt::string_codepage_from_wide

Definition at line 402 of file string_conv.h.

typedef string_ansi_from_utf8 pfc::stringcvt::string_os_from_utf8

Definition at line 516 of file string_conv.h.

typedef string_ansi_from_utf8 pfc::stringcvt::string_os_from_utf8_fast

Definition at line 518 of file string_conv.h.

typedef string_utf8_from_win1252 pfc::stringcvt::string_utf8_from_ansi

Definition at line 553 of file string_conv.h.

typedef string_utf8_from_ansi pfc::stringcvt::string_utf8_from_os

Definition at line 517 of file string_conv.h.

typedef string_utf8_from_wide_t pfc::stringcvt::string_utf8_from_wide

Definition at line 113 of file string_conv.h.

typedef string_utf8_from_win1252_t pfc::stringcvt::string_utf8_from_win1252

Definition at line 230 of file string_conv.h.

typedef string_wide_from_win1252 pfc::stringcvt::string_wide_from_ansi

Definition at line 551 of file string_conv.h.

typedef string_wide_from_codepage_t pfc::stringcvt::string_wide_from_codepage

Definition at line 378 of file string_conv.h.

typedef string_wide_from_utf8_t pfc::stringcvt::string_wide_from_utf8

Definition at line 160 of file string_conv.h.

typedef string_wide_from_utf8_t<alloc_fast_aggressive> pfc::stringcvt::string_wide_from_utf8_fast

Definition at line 161 of file string_conv.h.

typedef string_wide_from_win1252_t pfc::stringcvt::string_wide_from_win1252

Definition at line 184 of file string_conv.h.

typedef string_win1252_from_utf8_t pfc::stringcvt::string_win1252_from_utf8

Definition at line 253 of file string_conv.h.

typedef string_win1252_from_wide_t pfc::stringcvt::string_win1252_from_wide

Definition at line 207 of file string_conv.h.

Enumeration Type Documentation

anonymous enum

Enumerator
codepage_system
codepage_ascii
codepage_iso_8859_1

Definition at line 279 of file string_conv.h.

              {
             codepage_system = CP_ACP,
             codepage_ascii = 20127,
             codepage_iso_8859_1 = 28591,
         };

Function Documentation

char pfc::stringcvt::charToASCII ( unsigned c )

Definition at line 144 of file string_conv.cpp.

                                        {
             if (c < 128) return (char)c;
             unsigned lo = 0, hi = PFC_TABSIZE(g_asciiMap);
             while( lo < hi ) {
                 const unsigned mid = (lo + hi) / 2;
                 const asciiMap_t entry = g_asciiMap[mid];
                 if ( c > entry.from ) {
                     lo = mid + 1;
                 } else if (c < entry.from) {
                     hi = mid;
                 } else {
                     return (char)entry.to;
                 }
             }
             return '?';
         }

t_size pfc::stringcvt::convert_ansi_to_wide	(	wchar_t *	p_out,
		t_size	p_out_size,
		const char *	p_source,
		t_size	p_source_size
	)

inline

Converts string from system codepage to wide character.

Parameters

p_out	Output buffer, receives converted string, with null terminator.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.

Returns: Number of characters written, not counting null terminator.

Definition at line 326 of file string_conv.h.

                                                                                                                          {
             return convert_codepage_to_wide(codepage_system,p_out,p_out_size,p_source,p_source_size);
         }

t_size pfc::stringcvt::convert_codepage_to_wide	(	unsigned	p_codepage,
		wchar_t *	p_out,
		t_size	p_out_size,
		const char *	p_source,
		t_size	p_source_size
	)

Converts string from specified codepage to wide character.

Parameters

p_out	Output buffer, receives converted string, with null terminator.
p_codepage	Codepage ID of source string.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.

Returns: Number of characters written, not counting null terminator.

Definition at line 428 of file string_conv.cpp.

                                                                                                                                           {
             if (p_out_size == 0) return 0;
             memset(p_out,0,p_out_size * sizeof(*p_out));
             MultiByteToWideChar(p_codepage,0,p_source,p_source_size,p_out,p_out_size);
             p_out[p_out_size-1] = 0;
             return wcslen(p_out);
         }

t_size pfc::stringcvt::convert_utf8_to_ascii	(	char *	p_out,
		t_size	p_out_size,
		const char *	p_in,
		t_size	p_in_size
	)

Definition at line 400 of file string_conv.cpp.

                                                                                                              {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<char> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 writer.write( charToASCII(newchar) );
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_utf8_to_wide	(	wchar_t *	p_out,
		t_size	p_out_size,
		const char *	p_source,
		t_size	p_source_size
	)

Converts UTF-8 characters to wide character.

Parameters

p_out	Output buffer, receives converted string, with null terminator.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters written, not counting null terminator.

Definition at line 161 of file string_conv.cpp.

                                                                                                           {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<wchar_t> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 writer.write_as_wide(newchar);
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_utf8_to_wide_unchecked	(	wchar_t *	p_out,
		const char *	p_in
	)

Definition at line 178 of file string_conv.cpp.

                                                                                  {
             t_size inptr = 0;
             string_writer_t<wchar_t,false> writer(p_out,~0);
             
             while(!writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar);
                 if (delta == 0 || newchar == 0) break;
                 inptr += delta;
                 writer.write_as_wide(newchar);
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_utf8_to_win1252	(	char *	p_out,
		t_size	p_out_size,
		const char *	p_in,
		t_size	p_in_size
	)

Definition at line 342 of file string_conv.cpp.

                                                                                                                {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<char> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 char temp;
                 if (!charExport1252( temp, newchar )) temp = '?';
                 writer.write( temp );
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_wide_to_ansi	(	char *	p_out,
		t_size	p_out_size,
		const wchar_t *	p_source,
		t_size	p_source_size
	)

inline

Converts string from wide character to system codepage.

Parameters

p_out	Output buffer, receives converted string, with null terminator.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters written, not counting null terminator.

Definition at line 344 of file string_conv.h.

                                                                                                                          {
             return convert_wide_to_codepage(codepage_system,p_out,p_out_size,p_source,p_source_size);
         }

t_size pfc::stringcvt::convert_wide_to_codepage	(	unsigned	p_codepage,
		char *	p_out,
		t_size	p_out_size,
		const wchar_t *	p_source,
		t_size	p_source_size
	)

Converts string from wide character to specified codepage.

Parameters

p_codepage	Codepage ID of source string.
p_out	Output buffer, receives converted string, with null terminator.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters written, not counting null terminator.

Definition at line 436 of file string_conv.cpp.

                                                                                                                                           {
             if (p_out_size == 0) return 0;
             memset(p_out,0,p_out_size * sizeof(*p_out));
             WideCharToMultiByte(p_codepage,0,p_source,p_source_size,p_out,p_out_size,0,FALSE);
             p_out[p_out_size-1] = 0;
             return strlen(p_out);
         }

t_size pfc::stringcvt::convert_wide_to_utf8	(	char *	p_out,
		t_size	p_out_size,
		const wchar_t *	p_source,
		t_size	p_source_size
	)

Converts wide character string to UTF-8.

Parameters

p_out	Output buffer, receives converted string, with null terminator.
p_out_size	Size of output buffer, in characters. If converted string is too long, it will be truncated. Null terminator is always written, unless p_out_size is zero.
p_source	String to convert.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters written, not counting null terminator.

Definition at line 193 of file string_conv.cpp.

                                                                                                           {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<char> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = wide_decode_char(p_in + inptr,&newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 writer.write_as_utf8(newchar);
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_wide_to_win1252	(	char *	p_out,
		t_size	p_out_size,
		const wchar_t *	p_in,
		t_size	p_in_size
	)

Definition at line 284 of file string_conv.cpp.

                                                                                                                   {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<char> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 unsigned newchar = 0;
                 t_size delta = wide_decode_char(p_in + inptr,&newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 char temp;
                 if (!charExport1252( temp, newchar )) temp = '?';
                 writer.write( temp );
             }
             
             return writer.finalize();
             
         }

t_size pfc::stringcvt::convert_win1252_to_utf8	(	char *	p_out,
		t_size	p_out_size,
		const char *	p_in,
		t_size	p_in_size
	)

Definition at line 379 of file string_conv.cpp.

                                                                                                                {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<char> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 char inChar = p_in[inptr];
                 if (inChar == 0) break;
                 ++inptr;
                 
                 unsigned out;
                 if (!charImport1252( out , inChar )) out = '?';
                 writer.write_as_utf8( out );
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::convert_win1252_to_wide	(	wchar_t *	p_out,
		t_size	p_out_size,
		const char *	p_in,
		t_size	p_in_size
	)

Definition at line 309 of file string_conv.cpp.

                                                                                                                   {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             string_writer_t<wchar_t> writer(p_out,p_out_size);
             
             while(inptr < insize && !writer.is_overrun()) {
                 char inChar = p_in[inptr];
                 if (inChar == 0) break;
                 ++inptr;
                 
                 unsigned out;
                 if (!charImport1252( out , inChar )) out = '?';
                 writer.write_as_wide( out );
             }
             
             return writer.finalize();
         }

t_size pfc::stringcvt::estimate_ansi_to_wide	(	const char *	p_source,
		t_size	p_source_size
	)

inline

Estimates buffer size required to convert specified system codepage string to wide character.

Parameters

p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 334 of file string_conv.h.

                                                                                         {
             return estimate_codepage_to_wide(codepage_system,p_source,p_source_size);
         }

t_size pfc::stringcvt::estimate_codepage_to_wide	(	unsigned	p_codepage,
		const char *	p_source,
		t_size	p_source_size
	)

Estimates buffer size required to convert specified string from specified codepage to wide character.

Parameters

p_codepage	Codepage ID of source string.
p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 444 of file string_conv.cpp.

                                                                                                          {
             return MultiByteToWideChar(p_codepage,0,p_source,strlen_max(p_source,p_source_size),0,0) + 1;
         }

t_size pfc::stringcvt::estimate_utf8_to_ascii	(	const char *	p_source,
		t_size	p_source_size
	)

Definition at line 397 of file string_conv.cpp.

                                                                                      {
             return estimate_utf8_to_win1252( p_source, p_source_size );
         }

t_size pfc::stringcvt::estimate_utf8_to_wide ( const char * p_in )

Definition at line 210 of file string_conv.cpp.

                                                         {
             t_size inptr = 0;
             t_size retval = 1;//1 for null terminator
             for(;;) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar);
                 if (delta == 0 || newchar == 0) break;
                 inptr += delta;
                 
                 {
                     wchar_t temp[2];
                     retval += wide_encode_char(newchar,temp);
                 }
             }
             return retval;
         }

t_size pfc::stringcvt::estimate_utf8_to_wide	(	const char *	p_source,
		t_size	p_source_size
	)

Estimates buffer size required to convert specified UTF-8 string to widechar.

Parameters

p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 227 of file string_conv.cpp.

                                                                          {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             t_size retval = 1;//1 for null terminator
             while(inptr < insize) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 {
                     wchar_t temp[2];
                     retval += wide_encode_char(newchar,temp);
                 }
             }
             return retval;
         }

t_size pfc::stringcvt::estimate_utf8_to_wide_quick ( t_size sourceLen )

inline

estimate_utf8_to_wide_quick() functions use simple math to determine buffer size required for the conversion. The result is not accurate length of output string - it's just a safe estimate of required buffer size, possibly bigger than what's really needed.
These functions are meant for scenarios when speed is more important than memory usage.

Definition at line 52 of file string_conv.h.

                                                                     {
             return sourceLen + 1;
         }

t_size pfc::stringcvt::estimate_utf8_to_wide_quick ( const char * source )

inline

Definition at line 55 of file string_conv.h.

                                                                        {
             return estimate_utf8_to_wide_quick(strlen(source));
         }

t_size pfc::stringcvt::estimate_utf8_to_wide_quick	(	const char *	source,
		t_size	sourceLen
	)

inline

Definition at line 58 of file string_conv.h.

                                                                                          {
             return estimate_utf8_to_wide_quick(strlen_max(source, sourceLen));
         }

t_size pfc::stringcvt::estimate_utf8_to_win1252	(	const char *	p_in,
		t_size	p_in_size
	)

Definition at line 327 of file string_conv.cpp.

                                                                                {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             t_size retval = 1;//1 for null terminator
             while(inptr < insize) {
                 unsigned newchar = 0;
                 t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 ++retval;
             }
             return retval;
         }

t_size pfc::stringcvt::estimate_wide_to_ansi	(	const wchar_t *	p_source,
		t_size	p_source_size
	)

inline

Estimates buffer size required to convert specified wide character string to system codepage.

Parameters

p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 352 of file string_conv.h.

                                                                                            {
             return estimate_wide_to_codepage(codepage_system,p_source,p_source_size);
         }

t_size pfc::stringcvt::estimate_wide_to_codepage	(	unsigned	p_codepage,
		const wchar_t *	p_source,
		t_size	p_source_size
	)

Estimates buffer size required to convert specified wide character string to specified codepage.

Parameters

p_codepage	Codepage ID of source string.
p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 447 of file string_conv.cpp.

                                                                                                             {
             return WideCharToMultiByte(p_codepage,0,p_source,wcslen_max(p_source,p_source_size),0,0,0,FALSE) + 1;
         }

t_size pfc::stringcvt::estimate_wide_to_utf8	(	const wchar_t *	p_source,
		t_size	p_source_size
	)

Estimates buffer size required to convert specified wide character string to UTF-8.

Parameters

p_source	String to be converted.
p_source_size	Number of characters to read from p_source. If reading stops if null terminator is encountered earlier.

Returns: Number of characters to allocate, including space for null terminator.

Definition at line 246 of file string_conv.cpp.

                                                                             {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             t_size retval = 1;//1 for null terminator
             while(inptr < insize) {
                 unsigned newchar = 0;
                 t_size delta = wide_decode_char(p_in + inptr,&newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 {
                     char temp[6];
                     delta = utf8_encode_char(newchar,temp);
                     if (delta == 0) break;
                     retval += delta;
                 }
             }
             return retval;
         }

t_size pfc::stringcvt::estimate_wide_to_win1252	(	const wchar_t *	p_in,
		t_size	p_in_size
	)

Definition at line 267 of file string_conv.cpp.

                                                                                   {
             const t_size insize = p_in_size;
             t_size inptr = 0;
             t_size retval = 1;//1 for null terminator
             while(inptr < insize) {
                 unsigned newchar = 0;
                 t_size delta = wide_decode_char(p_in + inptr,&newchar,insize - inptr);
                 if (delta == 0 || newchar == 0) break;
                 PFC_ASSERT(inptr + delta <= insize);
                 inptr += delta;
                 
                 ++retval;
             }
             return retval;
             
         }

t_size pfc::stringcvt::estimate_win1252_to_utf8	(	const char *	p_in,
		t_size	p_in_size
	)

Definition at line 362 of file string_conv.cpp.

                                                                                {
             const size_t insize = p_in_size;
             t_size inptr = 0;
             t_size retval = 1; // 1 for null terminator
             while(inptr < insize) {
                 unsigned newchar;
                 char c = p_in[inptr];
                 if (c == 0) break;
                 ++inptr;
                 if (!charImport1252( newchar, c)) newchar = '?';
                 
                 char temp[6];
                 retval += pfc::utf8_encode_char( newchar, temp );
             }
             return retval;
         }

t_size pfc::stringcvt::estimate_win1252_to_wide	(	const char *	p_source,
		t_size	p_source_size
	)

Definition at line 305 of file string_conv.cpp.

                                                                                        {
             return strlen_max_t( p_source, p_source_size ) + 1;
         }

template<typename t_char >

const t_char* pfc::stringcvt::null_string_t ( )

template<>

const char* pfc::stringcvt::null_string_t< char > ( )

inline

Definition at line 64 of file string_conv.h.

64 {return "";}

template<>

const wchar_t* pfc::stringcvt::null_string_t< wchar_t > ( )

inline

Definition at line 65 of file string_conv.h.

65 {return L"";}

template<typename t_char >

bool pfc::stringcvt::string_is_empty_t	(	const t_char *	p_string,
		t_size	p_string_size = `~0`
	)

Definition at line 74 of file string_conv.h.

                                                                                                             {
             if (p_string_size == 0) return true;
             return p_string[0] == 0;
         }

template<typename t_char >

t_size pfc::stringcvt::strlen_t	(	const t_char *	p_string,
		t_size	p_string_size = `~0`
	)

Definition at line 67 of file string_conv.h.

                                                                                                      {
             for(t_size n=0;n<p_string_size;n++) {
                 if (p_string[n] == 0) return n;
             }
             return p_string_size;
         }

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation