hyzboy/CMCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use U8String/U16String/WString instead of UTF8String/UTF16String/WideString

Browse Source
This commit is contained in:
hyzboy 2024-12-24 22:39:02 +08:00
parent 413e48cd18
commit e416162a1e
24 changed files with 197 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
inc/hgl/CodePage.h
View File

@ -252,44 +252,44 @@ namespace hgl
return u8_to_u16(str,hgl::strlen<u8char>(str)+1,len);
}
inline UTF16String to_u16(const u8char *u8_str,int length)
inline U16String to_u16(const u8char *u8_str,int length)
{
int wlen;
u16char *ws=u8_to_u16(u8_str,length,wlen);
return UTF16String::newOf(ws,wlen);
return U16String::newOf(ws,wlen);
}
inline UTF16String to_u16(const UTF8String &u8str)
inline U16String to_u16(const U8String &u8str)
{
return to_u16(u8str.c_str(),u8str.Length());
}
inline UTF16String to_u16(const u8char *str)
inline U16String to_u16(const u8char *str)
{
int wlen;
u16char *ws=u8_to_u16(str,hgl::strlen(str),wlen);
return UTF16String::newOf(ws,wlen);
return U16String::newOf(ws,wlen);
}
inline UTF8String to_u8(const u16char *wide_str,int length)
inline U8String to_u8(const u16char *wide_str,int length)
{
int ulen;
u8char *us=u16_to_u8(wide_str,length,ulen);
return UTF8String::newOf(us,ulen);
return U8String::newOf(us,ulen);
}
inline UTF8String to_u8(const UTF16String &ws)
inline U8String to_u8(const U16String &ws)
{
return to_u8(ws.c_str(),ws.Length());
}
#if HGL_OS == HGL_OS_Windows
AnsiString ToAnsiString(const CharSet &cs,const UTF16String &str);
inline AnsiString ToAnsiString(const UTF16String &str)
AnsiString ToAnsiString(const CharSet &cs,const U16String &str);
inline AnsiString ToAnsiString(const U16String &str)
{
const CharSet cs((uint16)0);
@ -298,16 +298,16 @@ namespace hgl
inline OSString ToOSString(const char *str){return to_u16((u8char *)str);}
inline OSString ToOSString(const u8char *str){return to_u16(str);}
inline OSString ToOSString(const UTF8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
inline OSString ToOSString(const U8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
inline UTF8String ToUTF8String(const os_char *str){return to_u8(str,strlen(str));}
inline UTF8String ToUTF8String(const OSString &str){return to_u8(str);}
inline U8String ToU8String(const os_char *str){return to_u8(str,strlen(str));}
inline U8String ToU8String(const OSString &str){return to_u8(str);}
#else
inline OSString ToOSString(const char *str){return OSString(str);}
inline OSString ToOSString(const UTF8String &str){return str;}
inline OSString ToOSString(const U8String &str){return str;}
inline UTF8String ToUTF8String(const os_char *str){return UTF8String(str);}
inline UTF8String ToUTF8String(const OSString &str){return str;}
inline U8String ToU8String(const os_char *str){return U8String(str);}
inline U8String ToU8String(const OSString &str){return str;}
#endif//
const BOMFileHeader *ParseBOM(const void *input);

4
inc/hgl/filesystem/Filename.h
View File

@ -360,11 +360,11 @@ namespace hgl
{return MergeFilename<char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_RAWSTR);}
#endif//HGL_SUPPORT_CHAR8_T
inline UTF8String MergeFilename(const UTF8String &pathname,const UTF8String &filename) ///<组合路径名与文件名
inline U8String MergeFilename(const U8String &pathname,const U8String &filename) ///<组合路径名与文件名
{return MergeFilename<u8char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);}
#if HGL_OS == HGL_OS_Windows
inline WideString MergeFilename(const WideString &pathname,const WideString &filename) ///<组合路径名与文件名
inline WString MergeFilename(const WString &pathname,const WString &filename) ///<组合路径名与文件名
{return MergeFilename<wchar_t>(pathname,filename,L'\\',L"\\");}
#endif//HGL_OS == HGL_OS_Windows

26
inc/hgl/io/DataInputStream.h
View File

@ -172,37 +172,37 @@ namespace hgl
virtual bool ReadUTF16BEChars(u16char *,uint); ///<读取utf16-be格式字符阵列到u16char *
//32bit str-length
virtual bool ReadUTF8String (char *, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF8String (UTF8String &, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF8String (UTF16String &, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadU8String (char *, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadU8String (U8String &, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadU8String (U16String &, uint max_len=0); ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF16LEString (u16char *, uint max_len=0);
virtual bool ReadUTF16BEString (u16char *, uint max_len=0);
virtual bool ReadUTF16LEString (UTF16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF16BEString (UTF16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF16LEString (U16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀四字节的字符串字节长度)
virtual bool ReadUTF16BEString (U16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀四字节的字符串字节长度)
//16bit str-length
virtual bool ReadUTF8ShortString (char *, uint max_len=0);
virtual bool ReadUTF8ShortString (UTF8String &, uint max_len=0); ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF8ShortString (UTF16String &, uint max_len=0); ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF8ShortString (U8String &, uint max_len=0); ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF8ShortString (U16String &, uint max_len=0); ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF16LEShortString (u16char *, uint max_len=0);
virtual bool ReadUTF16BEShortString (u16char *, uint max_len=0);
virtual bool ReadUTF16LEShortString (UTF16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF16BEShortString (UTF16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF16LEShortString (U16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀2字节的字符串字节长度)
virtual bool ReadUTF16BEShortString (U16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀2字节的字符串字节长度)
//8bit str-length
virtual bool ReadUTF8TinyString (char *, uint max_len=0);
virtual bool ReadUTF8TinyString (UTF8String &, uint max_len=0); ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF8TinyString (UTF16String &, uint max_len=0); ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF8TinyString (U8String &, uint max_len=0); ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF8TinyString (U16String &, uint max_len=0); ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF16LETinyString (u16char *, uint max_len=0);
virtual bool ReadUTF16BETinyString (u16char *, uint max_len=0);
virtual bool ReadUTF16LETinyString (UTF16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF16BETinyString (UTF16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF16LETinyString (U16String &, uint max_len=0); ///<读取utf16-le格式字符串(前缀1字节的字符串字节长度)
virtual bool ReadUTF16BETinyString (U16String &, uint max_len=0); ///<读取utf16-be格式字符串(前缀1字节的字符串字节长度)
};//class DataInputStream
template<> bool inline DataInputStream::ReadNumber<int8>(int8 &value){return ReadInt8(value);}

52
inc/hgl/io/DataOutputStream.h
View File

@ -138,52 +138,52 @@ namespace hgl
template<typename T> bool WriteUTF16LEChars (const String<T> &str){return WriteUTF16LEChars (str.c_str(),str.Length());}
template<typename T> bool WriteUTF16BEChars (const String<T> &str){return WriteUTF16BEChars (str.c_str(),str.Length());}
template<typename T> bool WriteUTF8StringWithLength (const u8char *str,const uint length);
template<typename T> bool WriteUTF8StringWithLength (const UTF16String &str);
template<typename T> bool WriteU8StringWithLength (const u8char *str,const uint length);
template<typename T> bool WriteU8StringWithLength (const U16String &str);
template<uchar C,typename T> bool WriteUTF16StringWithLength(const u16char *str,const uint len);
template<uchar C,typename T> bool WriteU16StringWithLength(const u16char *str,const uint len);
public:
//32 bit length
bool WriteUTF8String (const u8char *str,uint length); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const u8char *str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const UTF8String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const UTF16String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteU8String (const u8char *str,uint length); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteU8String (const u8char *str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteU8String (const U8String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteU8String (const U16String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const u16char *str,uint len); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const u16char *str,uint len); ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const UTF16String &str ); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const UTF16String &str ); ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const U16String &str ); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const U16String &str ); ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const u16char *str ); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const u16char *str ); ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const UTF8String &str ){return WriteUTF16LEString(to_u16(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const UTF8String &str ){return WriteUTF16BEString(to_u16(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16LEString (const U8String &str ){return WriteUTF16LEString(to_u16(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF16BEString (const U8String &str ){return WriteUTF16BEString(to_u16(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteAnsiString (const char *str,uint length){return WriteUTF8String((u8char *)str,length);}
bool WriteAnsiString (const char *str ){return WriteUTF8String((u8char *)str);}
bool WriteAnsiString (const AnsiString &str ){return WriteUTF8String((u8char *)str.c_str(),str.Length());}
bool WriteAnsiString (const char *str,uint length){return WriteU8String((u8char *)str,length);}
bool WriteAnsiString (const char *str ){return WriteU8String((u8char *)str);}
bool WriteAnsiString (const AnsiString &str ){return WriteU8String((u8char *)str.c_str(),str.Length());}
//16 bit length
bool WriteUTF8ShortString (const u8char *str,uint length); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const u8char *str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const UTF8String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const UTF16String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const U8String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const U16String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const u16char *str,uint len); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const u16char *str,uint len); ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const UTF16String &str ); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const UTF16String &str ); ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const U16String &str ); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const U16String &str ); ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const u16char *str ); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const u16char *str ); ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const UTF8String &str ){return WriteUTF16LEShortString(to_u16(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const UTF8String &str ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16LEShortString(const U8String &str ){return WriteUTF16LEShortString(to_u16(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF16BEShortString(const U8String &str ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteAnsiShortString (const char *str,uint length){return WriteUTF8ShortString((u8char *)str,length);}
bool WriteAnsiShortString (const char *str ){return WriteUTF8ShortString((u8char *)str);}
@ -192,20 +192,20 @@ namespace hgl
//8 bit length
bool WriteUTF8TinyString (const u8char *str,uint length); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const u8char *str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const UTF8String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const UTF16String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const U8String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const U16String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const u16char *str,uint len); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const u16char *str,uint len); ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const UTF16String &str ); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const UTF16String &str ); ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const U16String &str ); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const U16String &str ); ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const u16char *str ); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const u16char *str ); ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const UTF8String &str ){return WriteUTF16LETinyString(to_u16(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const UTF8String &str ){return WriteUTF16BETinyString(to_u16(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16LETinyString (const U8String &str ){return WriteUTF16LETinyString(to_u16(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF16BETinyString (const U8String &str ){return WriteUTF16BETinyString(to_u16(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteAnsiTinyString (const char *str,uint length){return WriteUTF8TinyString((u8char *)str,length);}
bool WriteAnsiTinyString (const char *str ){return WriteUTF8TinyString((u8char *)str);}

2
inc/hgl/io/JavaInputStream.h
View File

@ -61,7 +61,7 @@ namespace hgl
return in?in->ReadUTF16BEChars(wstr,count):false;
}
bool readUTF (UTF16String &str)
bool readUTF (U16String &str)
{
return in?in->ReadUTF8ShortString(str):false;
}

4
inc/hgl/io/JavaOutputStream.h
View File

@ -54,8 +54,8 @@ namespace hgl
return out?out->WriteUTF16BEChars(wstr,count):false;
}
bool writeUTF (const UTF8String &str){return out?out->WriteUTF8ShortString(str):false;}
bool writeUTF (const UTF16String &str){return out?out->WriteUTF8ShortString(str):false;}
bool writeUTF (const U8String &str){return out?out->WriteUTF8ShortString(str):false;}
bool writeUTF (const U16String &str){return out?out->WriteUTF8ShortString(str):false;}
};//class JavaOutputStream
}//namespace io
}//namespace hgl

8
inc/hgl/io/LoadString.h
View File

@ -6,9 +6,9 @@
namespace hgl
{
int LoadStringFromText(UTF8String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到UTF8String
int LoadStringFromText(UTF16String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到UTF16String
int LoadStringFromTextFile(UTF8String &str,const OSString &filename,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到UTF8String
int LoadStringFromTextFile(UTF16String &str,const OSString &filename,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到UTF16String
int LoadStringFromText(U8String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到U8String
int LoadStringFromText(U16String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到U16String
int LoadStringFromTextFile(U8String &str,const OSString &filename,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到U8String
int LoadStringFromTextFile(U16String &str,const OSString &filename,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到U16String
}//namespace hgl
#endif//HGL_LOAD_STRING_INCLUDE

16
inc/hgl/io/LoadStringList.h
View File

@ -14,7 +14,7 @@ namespace hgl
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF8String(str);
return dis->ReadU8String(str);
}
};
@ -66,13 +66,13 @@ namespace hgl
return(result);
}//int LoadStringList
inline int LoadUTF8StringList (UTF8StringList & sl,io::DataInputStream *dis){return LoadStringList<u8char, ByteOrderMask::UTF8 >(sl,dis);}
inline int LoadUTF16LEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16LE >(sl,dis);}
inline int LoadUTF16BEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16BE >(sl,dis);}
inline int LoadU8StringList (U8StringList & sl,io::DataInputStream *dis){return LoadStringList<u8char, ByteOrderMask::UTF8 >(sl,dis);}
inline int LoadUTF16LEStringList (U16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16LE >(sl,dis);}
inline int LoadUTF16BEStringList (U16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16BE >(sl,dis);}
int LoadStringListFromText( UTF8StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到UTF8StringList
int LoadStringListFromText( UTF16StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到UTF16StringList
int LoadStringListFromTextFile( UTF8StringList &sl,const OSString &filename, const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到UTF8StringList
int LoadStringListFromTextFile( UTF16StringList &sl,const OSString &filename, const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到UTF16StringList
int LoadStringListFromText( U8StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到U8StringList
int LoadStringListFromText( U16StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet); ///<加载一个原始文本块到U16StringList
int LoadStringListFromTextFile( U8StringList &sl,const OSString &filename, const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到U8StringList
int LoadStringListFromTextFile( U16StringList &sl,const OSString &filename, const CharSet &cs=UTF8CharSet); ///<加载一个原始文本文件到U16StringList
}//namespace hgl
#endif//HGL_LOAD_STRING_LIST_INCLUDE

4
inc/hgl/io/SaveStringList.h
View File

@ -14,7 +14,7 @@ namespace hgl
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF8String(str);
return dos->WriteU8String(str);
}
};
@ -55,7 +55,7 @@ namespace hgl
return(result);
};
template<typename T> int SaveUTF8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
template<typename T> int SaveU8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF8>(dos,sl);
}

12
inc/hgl/log/LogInfo.h
View File

@ -21,12 +21,12 @@ namespace hgl
void Log(LogLevel level,const u16char *str,int size);
void Log(LogLevel level,const u8char *str,int size);
inline void Log(LogLevel ll,const UTF16String &str)
inline void Log(LogLevel ll,const U16String &str)
{
Log(ll,str.c_str(),str.Length());
}
inline void Log(LogLevel ll,const UTF8String &str)
inline void Log(LogLevel ll,const U8String &str)
{
Log(ll,str.c_str(),str.Length());
}
@ -38,14 +38,14 @@ namespace hgl
}
#endif//HGL_SUPPORT_CHAR8_T
inline void DebugLog(LogLevel ll,const UTF16String &str,const char *filename,int line,const char *funcname)
inline void DebugLog(LogLevel ll,const U16String &str,const char *filename,int line,const char *funcname)
{
Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+UTF16String::numberOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+U16String::numberOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
}
inline void DebugLog(LogLevel ll,const UTF8String &str,const char *filename,int line,const char *funcname)
inline void DebugLog(LogLevel ll,const U8String &str,const char *filename,int line,const char *funcname)
{
Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String((u8char *)filename)+U8_TEXT("\", ")+UTF8String::numberOf(line)+U8_TEXT(" line,func:\"")+UTF8String((u8char *)funcname)+U8_TEXT("\")"));
Log(ll,str+U8_TEXT(">>LogFrom(\"")+U8String((u8char *)filename)+U8_TEXT("\", ")+U8String::numberOf(line)+U8_TEXT(" line,func:\"")+U8String((u8char *)funcname)+U8_TEXT("\")"));
}
#define LOG_INFO(str) {Log(LogLevel::Log, str);}

4
inc/hgl/plugin/PlugIn.h
View File

@ -15,7 +15,7 @@ namespace hgl
uint ver;
OSString name;
UTF16String intro;
U16String intro;
OSString filename; ///<插件文件名
@ -23,7 +23,7 @@ namespace hgl
const uint GetVersion ()const{return ver;} ///<取得插件版本
const OSString & GetName ()const{return name;} ///<取得插件名称
const UTF16String & GetIntro ()const{return intro;} ///<取得插件介绍
const U16String & GetIntro ()const{return intro;} ///<取得插件介绍
public:

2
inc/hgl/plugin/PlugInManage.h
View File

@ -28,7 +28,7 @@ namespace hgl
PlugIn *LoadPlugin (const OSString &,const OSString &); ///<加载一个外部插件，明确指定全路径文件名
PlugIn *LoadPlugin (const OSString &); ///<加载一个外部插件，自行查找
bool UnloadPlugin(const OSString &); ///<释放一个外部插件
};//class PlugInManage:public ObjectManage<UTF16String,PlugIn>
};//class PlugInManage:public ObjectManage<U16String,PlugIn>
/**
* 插件注册模板

2
inc/hgl/thread/Loader.h
View File

@ -38,7 +38,7 @@ namespace hgl
void SetStatus(LoaderStatus);
HAC *loader_hac;
UTF16String loader_filename;
U16String loader_filename;
void *loader_pointer;
void *loader_data;
int loader_size;

4
inc/hgl/thread/Thread.h
View File

@ -37,7 +37,7 @@ namespace hgl
friend THREAD_FUNC ThreadFunc(Thread *tc);
#ifdef _DEBUG
UTF8String thread_addr_string; ///<线程地址用字符串，调试使用
U8String thread_addr_string; ///<线程地址用字符串，调试使用
#endif//_DEBUG
public:
@ -45,7 +45,7 @@ namespace hgl
virtual ~Thread()=default;
#ifdef _DEBUG
const UTF8String &GetThreadAddressString()const{return thread_addr_string;} ///<取得线程地址字符串
const U8String &GetThreadAddressString()const{return thread_addr_string;} ///<取得线程地址字符串
#endif//_DEBUG
/**

6
inc/hgl/type/ConstStringSet.h
View File

@ -180,9 +180,9 @@ namespace hgl
}
};//class ConstStringSet
using ConstWideStringSet =ConstStringSet<wchar_t>;
using ConstUTF8StringSet =ConstStringSet<u8char>;
using ConstUTF16StringSet =ConstStringSet<u16char>;
using ConstWStringSet =ConstStringSet<wchar_t>;
using ConstU8StringSet =ConstStringSet<u8char>;
using ConstU16StringSet =ConstStringSet<u16char>;
// using ConstUTF32StringSet =ConstStringSet<u32char>;
using ConstOSStringSet =ConstStringSet<os_char>;

10
inc/hgl/type/StdString.h
View File

@ -17,14 +17,14 @@ namespace hgl
return hgl::OSString(str.c_str(),(int)str.length());
}
inline hgl::UTF8String ToUTF8String(const std::wstring &str)
inline hgl::U8String ToU8String(const std::wstring &str)
{
return hgl::to_u8(str.c_str(),(int)str.length());
}
inline std::string ToStdString(const hgl::OSString &str)
{
hgl::UTF8String u8_str=hgl::to_u8(str);
hgl::U8String u8_str=hgl::to_u8(str);
return std::string((char *)u8_str.c_str(),str.Length());
}
@ -51,14 +51,14 @@ namespace hgl
inline std::wstring ToStdWString(const OSString &str)
{
hgl::WideString w_str=hgl::to_wide<sizeof(wchar_t)>(str);
hgl::WString w_str=hgl::to_wide<sizeof(wchar_t)>(str);
return std::wstring(w_str.c_str(),w_str.Length());
}
#endif//
inline hgl::UTF8String ToUTF8String(const std::string &str)
inline hgl::U8String ToU8String(const std::string &str)
{
return hgl::UTF8String((hgl::u8char *)str.c_str(),int(str.size()));
return hgl::U8String((hgl::u8char *)str.c_str(),int(str.size()));
}
}

16
inc/hgl/type/String.h
View File

@ -1325,14 +1325,14 @@ namespace hgl
return String<T>(value)+str;
}
using AnsiString =String<char>;
using UTF8String =String<u8char>;
using UTF16String =String<u16char>;
using UTF32String =String<char32_t>;
using AnsiString=String<char>;
using U8String =String<u8char>;
using U16String =String<u16char>;
using U32String =String<char32_t>;
using OSString =String<os_char>;
using WideString =String<wchar_t>;
using WString =String<wchar_t>;
using ShaderString =UTF8String;
using ShaderString =U8String;
template<typename C> bool ToNumber(const String<C> &str,int &value){return str.ToInt(value);}
template<typename C> bool ToNumber(const String<C> &str,uint &value){return str.ToUint(value);}
@ -1398,12 +1398,12 @@ namespace hgl
return PointerToHexString<os_char>(value);
}
inline String<char> PointerToHexUTF8String(const void *value)
inline String<char> PointerToHexU8String(const void *value)
{
return PointerToHexString<char>(value);
}
inline String<u16char> PointerToHexUTF16String(const void *value)
inline String<u16char> PointerToHexU16String(const void *value)
{
return PointerToHexString<u16char>(value);
}

8
inc/hgl/type/StringList.h
View File

@ -296,11 +296,11 @@ namespace hgl
#define DEFINE_STRING_LIST(name) using name##StringList=StringList<name##String::CharType>;
DEFINE_STRING_LIST(UTF8)
DEFINE_STRING_LIST(UTF16)
DEFINE_STRING_LIST(UTF32)
DEFINE_STRING_LIST(U8)
DEFINE_STRING_LIST(U16)
DEFINE_STRING_LIST(U32)
DEFINE_STRING_LIST(Ansi)
DEFINE_STRING_LIST(Wide)
DEFINE_STRING_LIST(W)
DEFINE_STRING_LIST(OS)
#undef DEFINE_STRING_LIST

8
inc/hgl/type/StringView.h
View File

@ -58,11 +58,11 @@ namespace hgl
}
};//class StringView
using UTF8StringView=StringView<u8char>;
using UTF16StringView=StringView<u16char>;
using UTF32StringView=StringView<u32char>;
using U8StringView=StringView<u8char>;
using U16StringView=StringView<u16char>;
using U32StringView=StringView<u32char>;
using OSStringView =StringView<os_char>;
using AnsiStringView=StringView<char>;
using WideStringView=StringView<wchar_t>;
using WStringView=StringView<wchar_t>;
}//namespace hgl

52
src/IO/DataInputStream.cpp
View File

@ -38,7 +38,7 @@ namespace hgl
}
template<typename T>
bool ReadUTF8String(char *buf,uint max_len,DataInputStream *dis)
bool ReadU8String(char *buf,uint max_len,DataInputStream *dis)
{
if(!buf||!max_len||!dis)
return(false);
@ -73,12 +73,12 @@ namespace hgl
return(true);
}
bool DataInputStream::ReadUTF8String (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u8str,max_len,this);}
bool DataInputStream::ReadU8String (char *u8str,uint max_len){return hgl::io::ReadU8String<uint32>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (char *u8str,uint max_len){return hgl::io::ReadU8String<uint16>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (char *u8str,uint max_len){return hgl::io::ReadU8String<uint8 >(u8str,max_len,this);}
template<typename T>
bool ReadUTF8String(UTF8String &u8str,uint max_len,DataInputStream *dis)
bool ReadU8String(U8String &u8str,uint max_len,DataInputStream *dis)
{
if(!max_len||!dis)
return(false);
@ -108,12 +108,12 @@ namespace hgl
return(true);
}
bool DataInputStream::ReadUTF8String (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u8str,max_len,this);}
bool DataInputStream::ReadU8String (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint32>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint16>(u8str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint8 >(u8str,max_len,this);}
template<typename T>
bool ReadUTF8String(UTF16String &u16str,uint max_len,DataInputStream *dis)
bool ReadU8String(U16String &u16str,uint max_len,DataInputStream *dis)
{
if(!max_len||!dis)
return(false);
@ -149,12 +149,12 @@ namespace hgl
return(true);
}
bool DataInputStream::ReadUTF8String (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u16str,max_len,this);}
bool DataInputStream::ReadU8String (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF8ShortString (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF8TinyString (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint8 >(u16str,max_len,this);}
template<char E,typename T>
bool ReadUTF16String(u16char *str,uint max_len,DataInputStream *dis)
bool ReadU16String(u16char *str,uint max_len,DataInputStream *dis)
{
if(!dis)return(false);
if(!str||!max_len)return(false);
@ -192,16 +192,16 @@ namespace hgl
return(true);
}
bool DataInputStream::ReadUTF16LEString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16LEShortString(u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16LETinyString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,max_len,this);}
bool DataInputStream::ReadUTF16LEString (u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16LEShortString(u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16LETinyString (u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BEString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BEShortString(u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BETinyString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint8 >(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BEString (u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint32>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BEShortString(u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint16>(u16str,max_len,this);}
bool DataInputStream::ReadUTF16BETinyString (u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint8 >(u16str,max_len,this);}
template<char E,typename T>
bool ReadUTF16String(UTF16String &str,DataInputStream *dis,uint max_len)
bool ReadU16String(U16String &str,DataInputStream *dis,uint max_len)
{
if(!dis||!max_len)return(false);
@ -237,12 +237,12 @@ namespace hgl
return(true);
}
bool DataInputStream::ReadUTF16LEString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint32>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16LEShortString(UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint16>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16LETinyString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,this,max_len);}
bool DataInputStream::ReadUTF16LEString (U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint32>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16LEShortString(U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint16>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16LETinyString (U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BEString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint32>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BEShortString(UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint16>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BETinyString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint8 >(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BEString (U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint32>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BEShortString(U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint16>(u16str,this,max_len);}
bool DataInputStream::ReadUTF16BETinyString (U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint8 >(u16str,this,max_len);}
}//namespace io
}//namespace hgl

72
src/IO/DataOutputStream.cpp
View File

@ -27,7 +27,7 @@ namespace hgl
namespace io //write utf8 string
{
template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const u8char *str,const uint length)
template<typename T> bool DataOutputStream::WriteU8StringWithLength(const u8char *str,const uint length)
{
if(!out)return(false);
@ -42,14 +42,14 @@ namespace hgl
return WriteUTF8Chars(str,length);
}
template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const UTF16String &str)
template<typename T> bool DataOutputStream::WriteU8StringWithLength(const U16String &str)
{
if(!out)return(false);
int utf8_count;
u8char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count);
const bool result=WriteUTF8StringWithLength<T>(utf8_str,utf8_count);
const bool result=WriteU8StringWithLength<T>(utf8_str,utf8_count);
delete[] utf8_str;
@ -83,7 +83,7 @@ namespace hgl
if(length==0)return(true);
if(!out||!str||!*str)return(false);
UTF16String u16_str=to_u16(str);
U16String u16_str=to_u16(str);
return WriteUTF16Chars<HGL_LITTLE_ENDIAN>(this,u16_str.c_str(),u16_str.Length());
}
@ -104,7 +104,7 @@ namespace hgl
if(length==0)return(true);
if(!out||!str||!*str)return(false);
UTF16String u16_str=to_u16(str,length);
U16String u16_str=to_u16(str,length);
return WriteUTF16Chars<HGL_BIG_ENDIAN>(this,u16_str.c_str(),u16_str.Length());
}
@ -120,7 +120,7 @@ namespace hgl
namespace io //write utf16 string
{
template<uchar C,typename T> bool DataOutputStream::WriteUTF16StringWithLength(const u16char *str,const uint len)
template<uchar C,typename T> bool DataOutputStream::WriteU16StringWithLength(const u16char *str,const uint len)
{
if(!out)return(false);
if(len&&!str)return(false);
@ -136,50 +136,50 @@ namespace hgl
namespace io
{
bool DataOutputStream::WriteUTF8String (const u8char *str,uint length){return WriteUTF8StringWithLength<uint32>(str, length);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const u8char *str ){return WriteUTF8StringWithLength<uint32>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const UTF8String &str ){return WriteUTF8StringWithLength<uint32>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const UTF16String &str ){return WriteUTF8StringWithLength<uint32>(str);} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteU8String (const u8char *str,uint length){return WriteU8StringWithLength<uint32>(str, length);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteU8String (const u8char *str ){return WriteU8StringWithLength<uint32>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteU8String (const U8String &str ){return WriteU8StringWithLength<uint32>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteU8String (const U16String &str ){return WriteU8StringWithLength<uint32>(str);} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str, len);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint32>(str, len);} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str, len);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint32>(str, len);} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const UTF16String &str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str.c_str(),str.Length());} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const UTF16String &str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint32>(str.c_str(),str.Length());} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const U16String &str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str.c_str(),str.Length());} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const U16String &str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint32>(str.c_str(),str.Length());} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const u16char *str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const u16char *str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint32>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEString (const u16char *str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint32>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEString (const u16char *str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint32>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const u8char *str,uint length){return WriteUTF8StringWithLength<uint16>(str, length);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const u8char *str ){return WriteUTF8StringWithLength<uint16>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const UTF8String &str ){return WriteUTF8StringWithLength<uint16>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const UTF16String &str ){return WriteUTF8StringWithLength<uint16>(str);} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const u8char *str,uint length){return WriteU8StringWithLength<uint16>(str, length);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const u8char *str ){return WriteU8StringWithLength<uint16>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const U8String &str ){return WriteU8StringWithLength<uint16>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const U16String &str ){return WriteU8StringWithLength<uint16>(str);} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str, len);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint16>(str, len);} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str, len);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint16>(str, len);} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const UTF16String &str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str.c_str(),str.Length());} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const UTF16String &str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint16>(str.c_str(),str.Length());} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const U16String &str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str.c_str(),str.Length());} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const U16String &str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint16>(str.c_str(),str.Length());} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const u16char *str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const u16char *str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint16>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LEShortString(const u16char *str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint16>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BEShortString(const u16char *str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint16>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const u8char *str,uint length){return WriteUTF8StringWithLength<uint8>(str, length);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const u8char *str ){return WriteUTF8StringWithLength<uint8>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const UTF8String &str ){return WriteUTF8StringWithLength<uint8>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const UTF16String &str ){return WriteUTF8StringWithLength<uint8>(str);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const u8char *str,uint length){return WriteU8StringWithLength<uint8>(str, length);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const u8char *str ){return WriteU8StringWithLength<uint8>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const U8String &str ){return WriteU8StringWithLength<uint8>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const U16String &str ){return WriteU8StringWithLength<uint8>(str);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str, len);} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint8>(str, len);} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str, len);} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint8>(str, len);} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const UTF16String &str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str.c_str(), str.Length());} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const UTF16String &str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint8>(str.c_str(), str.Length());} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const U16String &str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str.c_str(), str.Length());} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const U16String &str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint8>(str.c_str(), str.Length());} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const u16char *str ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const u16char *str ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN, uint8>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16LETinyString (const u16char *str ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN, uint8>(str, hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF16BETinyString (const u16char *str ){return WriteU16StringWithLength<HGL_BIG_ENDIAN, uint8>(str, hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
}//namespace io
}//namespace hgl

12
src/Text/ConstStringSetSaveToTextStream.cpp
View File

@ -79,12 +79,12 @@ namespace hgl
//下面这些定义是为了实例化上面的函数，所以不要删掉
//bool SaveToAnsiTextStream(hgl::io::TextOutputStream *tos,const ConstAnsiStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToWideTextStream(hgl::io::TextOutputStream *tos,const ConstWideStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToUTF8TextStream(hgl::io::TextOutputStream *tos,const ConstUTF8StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToUTF16TextStream(hgl::io::TextOutputStream *tos,const ConstUTF16StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToWideTextStream(hgl::io::TextOutputStream *tos,const ConstWStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToUTF8TextStream(hgl::io::TextOutputStream *tos,const ConstU8StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
bool SaveToUTF16TextStream(hgl::io::TextOutputStream *tos,const ConstU16StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
//bool SaveToAnsiTextFile(const OSString &filename,const ConstAnsiStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToWideTextFile(const OSString &filename,const ConstWideStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToUTF8TextFile(const OSString &filename,const ConstUTF8StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToUTF16TextFile(const OSString &filename,const ConstUTF16StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToWideTextFile(const OSString &filename,const ConstWStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToUTF8TextFile(const OSString &filename,const ConstU8StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
bool SaveToUTF16TextFile(const OSString &filename,const ConstU16StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
}//namespace hgl

16
src/Text/LoadString.cpp
View File

@ -3,9 +3,9 @@
namespace hgl
{
/**
* 加载一个原始文本块到UTF8String
* 加载一个原始文本块到U8String
*/
int LoadStringFromText(UTF8String &full_text,const void *source_data,const int size,const CharSet &cs)
int LoadStringFromText(U8String &full_text,const void *source_data,const int size,const CharSet &cs)
{
if(!source_data||size<=0)
return 0;
@ -83,9 +83,9 @@ namespace hgl
}
/**
* 加载一个原始文本块到UTF16String
* 加载一个原始文本块到U16String
*/
int LoadStringFromText(UTF16String &full_text,const void *source_data,const int size,const CharSet &cs)
int LoadStringFromText(U16String &full_text,const void *source_data,const int size,const CharSet &cs)
{
if(!source_data||size<=0)
return(0);
@ -165,9 +165,9 @@ namespace hgl
}
/**
* 加载一个原始文本文件到UTF8String
* 加载一个原始文本文件到U8String
*/
int LoadStringFromTextFile(UTF8String &str,const OSString &filename,const CharSet &cs)
int LoadStringFromTextFile(U8String &str,const OSString &filename,const CharSet &cs)
{
uchar *data;
@ -180,9 +180,9 @@ namespace hgl
}
/**
* 加载一个原始文本文件到UTF16String
* 加载一个原始文本文件到U16String
*/
int LoadStringFromTextFile(UTF16String &str,const OSString &filename,const CharSet &cs)
int LoadStringFromTextFile(U16String &str,const OSString &filename,const CharSet &cs)
{
uchar *data;

20
src/Text/LoadStringList.cpp
View File

@ -6,11 +6,11 @@
namespace hgl
{
/**
* 加载一个原始文本块到UTF8StringList
* 加载一个原始文本块到U8StringList
*/
int LoadStringListFromText(UTF8StringList &sl,const void *data,const int size,const CharSet &cs)
int LoadStringListFromText(U8StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF8String str;
U8String str;
LoadStringFromText(str,data,size,cs);
@ -18,11 +18,11 @@ namespace hgl
}
/**
* 加载一个原始文本块到UTF16StringList
* 加载一个原始文本块到U16StringList
*/
int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &cs)
int LoadStringListFromText(U16StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF16String str;
U16String str;
LoadStringFromText(str,data,size,cs);
@ -30,9 +30,9 @@ namespace hgl
}
/**
* 加载一个原始文本文件到UTF8StringList
* 加载一个原始文本文件到U8StringList
*/
int LoadStringListFromTextFile(UTF8StringList &sl,const OSString &filename,const CharSet &cs)
int LoadStringListFromTextFile(U8StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;
@ -45,9 +45,9 @@ namespace hgl
}
/**
* 加载一个原始文本文件到UTF16StringList
* 加载一个原始文本文件到U16StringList
*/
int LoadStringListFromTextFile(UTF16StringList &sl,const OSString &filename,const CharSet &cs)
int LoadStringListFromTextFile(U16StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;