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

recreate SplitString calsses,and split LoadString/LoadStringList/SaveStringList/MergeString/SplitString......

Browse Source
This commit is contained in:
HuYingzhuo(hugo/hyzboy) 2022-08-05 12:21:25 +08:00
parent c1893a83ec
commit 37e6af6385
10 changed files with 373 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
inc/hgl/type/LoadString.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef HGL_LOAD_STRING_INCLUDE
#define HGL_LOAD_STRING_INCLUDE
#include<hgl/type/String.h>
#include<hgl/CodePage.h>
namespace hgl
{
int LoadStringFromText(UTF8String &full_text,const void *source_data,const int size,const CharSet &cs); ///<加载一个原始文本块到UTF8String
int LoadStringFromText(UTF16String &full_text,const void *source_data,const int size,const CharSet &cs); ///<加载一个原始文本块到UTF16String
int LoadStringFromTextFile(UTF8String &str,const OSString &filename,const CharSet &cs); ///<加载一个原始文本文件到UTF8String
int LoadStringFromTextFile(UTF16String &str,const OSString &filename,const CharSet &cs); ///<加载一个原始文本文件到UTF16String
}//namespace hgl
#endif//HGL_LOAD_STRING_INCLUDE

78
inc/hgl/type/LoadStringList.h Normal file
View File

@ -0,0 +1,78 @@
#ifndef HGL_LOAD_STRING_LIST_INCLUDE
#define HGL_LOAD_STRING_LIST_INCLUDE
#include<hgl/type/StringList.h>
namespace hgl
{
template<typename T,ByteOrderMask bom> struct ReadStringFromDIS
{
bool ReadString(io::DataInputStream *dis,T &str);
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF8>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF8String(str);
}
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF16LE>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF16LEString(str);
}
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF16BE>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF16BEString(str);
}
};
/**
* 从DataInputStream流中读取一个字符串列表
* @param sl 字符串列表处理类
* @param dis 数据输入流
* @return 字符串行数
*/
template<typename T,ByteOrderMask bom> int LoadStringList(StringList<T> &sl,io::DataInputStream *dis)
{
if(!dis)return(-1);
int count;
int result=0;
if(!dis->ReadInt32(count))
return(-2);
ReadStringFromDIS<String<T>,bom> rsfd;
String<T> str;
for(int i=0;i<count;i++)
{
if(!rsfd.ReadString(dis,str))
break;
sl.Add(str);
result++;
}
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);}
int LoadStringListFromText(UTF8StringList &sl,const void *data,const int size,const CharSet &cs); ///<加载一个原始文本块到UTF8StringList
int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &cs); ///<加载一个原始文本块到UTF16StringList
int LoadStringListFromTextFile(UTF8StringList &sl,const OSString &filename,const CharSet &cs); ///<加载一个原始文本文件到UTF8StringList
int LoadStringListFromTextFile(UTF16StringList &sl,const OSString &filename,const CharSet &cs); ///<加载一个原始文本文件到UTF16StringList
}//namespace hgl
#endif//HGL_LOAD_STRING_LIST_INCLUDE

12
inc/hgl/type/MergeString.h
View File

@ -1,14 +1,14 @@
#ifndef HGL_MERGE_STRING_INCLUDE
#ifndef HGL_MERGE_STRING_INCLUDE
#define HGL_MERGE_STRING_INCLUDE
#include<hgl/type/StringList.h>
namespace hgl
{
/**
* 将一个字符串列表整合成一个字符串
* @param sl 要整合的字符串列表
* @param end_line 换行符
* @return 字符串
* 将一个字符串列表整合成一个字符串
* @param sl 要整合的字符串列表
* @param end_line 换行符
* @return 字符串
*/
template<typename T> String<T> MergeString(const StringList<T> &sl,const String<T> &end_line)
{
@ -44,4 +44,4 @@ namespace hgl
return String<T>::newOf(str,total_chars);
}
}//namespace hgl
#endif//HGL_MERGE_STRING_INCLUDE
#endif//HGL_MERGE_STRING_INCLUDE

73
inc/hgl/type/SaveStringList.h Normal file
View File

@ -0,0 +1,73 @@
#ifndef HGL_SAVE_STRING_LIST_INCLUDE
#define HGL_SAVE_STRING_LIST_INCLUDE
#include<hgl/type/StringList.h>
namespace hgl
{
template<typename T,ByteOrderMask bom> struct WriteStringToDOS
{
bool WriteString(io::DataOutputStream *dos,const T &str);
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF8>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF8String(str);
}
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF16LE>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF16LEString(str);
}
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF16BE>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF16BEString(str);
}
};
template<typename T,ByteOrderMask bom> int WriteStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
WriteStringToDOS<T,bom> wtd;
const int32 count=sl.GetCount();
int result=0;
if(!dos->WriteInt32(count))
return(-2);
for(int32 i=0;i<count;i++)
{
if(!wtd.WriteString(dos,sl[i]))
return(-3);
result++;
}
return(result);
};
template<typename T> int SaveUTF8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF8>(dos,sl);
}
template<typename T> int SaveUTF16LEStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF16LE>(dos,sl);
}
template<typename T> int SaveUTF16BEStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF16BE>(dos,sl);
}
}//namespace hgl
#endif//HGL_SAVE_STRING_LIST_INCLUDE

262
inc/hgl/type/SplitString.h
View File

@ -1,11 +1,11 @@
#ifndef HGL_SPLIT_STRING_INCLUDE
#ifndef HGL_SPLIT_STRING_INCLUDE
#define HGL_SPLIT_STRING_INCLUDE
#include<hgl/type/StringList.h>
namespace hgl
{
/**
* 拆分字符串模板类
* 拆分字符串模板类
*/
template<typename T> class SplitString
{
@ -13,9 +13,9 @@ namespace hgl
virtual ~SplitString()=default;
virtual void OnNewString(const T *,const int)=0; ///<发现一个新的字符串
virtual void OnNewString(const T *,const int)=0; ///<发现一个新的字符串
virtual bool isSeparatorChar(const T &)=0; ///<是否是分隔符
virtual bool isSeparatorChar(const T &)=0; ///<是否是分隔符
virtual uint isSeparator(const T *str)
{
uint size=0;
@ -64,10 +64,10 @@ namespace hgl
++count;
}
p+=sc; ///<跳过分割符
p+=sc; ///<跳过分割符
size-=sc;
sp=p;
sp=p;
}
else
{
@ -92,7 +92,7 @@ namespace hgl
};//template<typename T> class SplitString
/**
* 拆分字符串到字符串列表模板类
* 拆分字符串到字符串列表模板类
*/
template<typename T> class SplitStringToStringList:public SplitString<T>
{
@ -132,7 +132,7 @@ namespace hgl
};//template<typename T> class SplitStringToStringList:public SplitString
/**
* 基于函数和指定条件拆分字符串到字符串列表模板类
* 基于函数和指定条件拆分字符串到字符串列表模板类
*/
template<typename T,typename C> class SplitStringToStringListByCondition:public SplitStringToStringList<T>
{
@ -141,7 +141,7 @@ namespace hgl
public:
SplitStringToStringListByCondition(StringList<T> *sl,const C (*func)(const T &),const C is_con):SplitStringToStringList(sl)
SplitStringToStringListByCondition(StringList<T> *sl,const C (*func)(const T &),const C is_con):SplitStringToStringList<T>(sl)
{
isFunc=func;
is_condition=is_con;
@ -169,40 +169,40 @@ namespace hgl
};//template<typename T,typename C> class SplitStringToStringListByCondition:public SplitStringToStringList<T>
/**
* 以不可打印字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 以不可打印字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListBySpace(StringList<T> &sl,const T *str,int size)
{
if(!str||size<=0)return(-1);
SplitStringToStringListByCondition split(&sl,isspace,true);
SplitStringToStringListByCondition<T,bool> split(&sl,isspace,true);
return split.Split(str,size);
}//int SplitToStringListBySpace
#define SPLIT_STRING_TO_STRING_LIST(name) template<typename T> int SplitToStringListBy##name(StringList<T> &sl,const String<T> &str) \
{ \
return SplitToStringListBy##name(sl,str.c_str(),str.Length()); \
return SplitToStringListBy##name<T>(sl,str.c_str(),str.Length()); \
}
SPLIT_STRING_TO_STRING_LIST(Space)
/**
* 拆分代码用字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 拆分代码用字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListByCodes(StringList<T> &sl,const T *str,int size)
{
if(!str||size<=0)return(-1);
SplitStringToStringListByCondition split(&sl,iscodechar,false);
SplitStringToStringListByCondition<T,bool> split(&sl,iscodechar,false);
return split.Split(str,size);
}//int SplitToStringListByCodes
@ -210,17 +210,17 @@ namespace hgl
SPLIT_STRING_TO_STRING_LIST(Codes)
/**
* 拆分数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 拆分数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListByDigit(StringList<T> &sl,const T *str,int size)
{
if(!str||size<=0)return(-1);
SplitStringToStringListByCondition split(&sl,isdigit,false);
SplitStringToStringListByCondition<T,bool> split(&sl,isdigit,false);
return split.Split(str,size);
}//int SplitToStringListByDigit
@ -228,17 +228,17 @@ namespace hgl
SPLIT_STRING_TO_STRING_LIST(Digit)
/**
* 拆分16进制数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 拆分16进制数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListByXDigit(StringList<T> &sl,const T *str,int size)
{
if(!str||size<=0)return(-1);
SplitStringToStringListByCondition split(&sl,isxdigit,false);
SplitStringToStringListByCondition<T,bool> split(&sl,isxdigit,false);
return split.Split(str,size);
}//int SplitToStringListByXDigit
@ -246,17 +246,17 @@ namespace hgl
SPLIT_STRING_TO_STRING_LIST(XDigit)
/**
* 拆分浮点数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 拆分浮点数字串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListByFloat(StringList<T> &sl,const T *str,int size)
{
if(!str||size<=0)return(-1);
SplitStringToStringListByCondition split(&sl,isfloat,false);
SplitStringToStringListByCondition<T,bool> split(&sl,isfloat,false);
return split.Split(str,size);
}//int SplitToStringListByFloat
@ -264,7 +264,7 @@ namespace hgl
SPLIT_STRING_TO_STRING_LIST(Float)
/**
* 基于指定字符拆分字符串到字符串列表模板类
* 基于指定字符拆分字符串到字符串列表模板类
*/
template<typename T> class SplitStringToStringListByChar:public SplitStringToStringList<T>
{
@ -272,7 +272,7 @@ namespace hgl
public:
SplitStringToStringListByChar(StringList<T> *sl,const T &sc):SplitStringToStringList(sl)
SplitStringToStringListByChar(StringList<T> *sl,const T &sc):SplitStringToStringList<T>(sl)
{
separator_char=sc;
}
@ -285,27 +285,29 @@ namespace hgl
};//template<typename T,typename C> class SplitStringToStringListByChar:public SplitStringToStringList<T>
/**
* 以指定字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @param split_char 分隔字符
* @return 字符串行数
* 以指定字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @param split_char 分隔字符
* @return 字符串行数
*/
template<typename T> int SplitToStringListByChar(StringList<T> &sl,const T *str,int size,const T &split_char)
{
SplitStringToStringListByChar split(&sl,split_char);
SplitStringToStringListByChar<T> split(&sl,split_char);
return split.Split(str,size);
}//int SplitToStringList
template<typename T> int SplitToStringListByChar(StringList<T> &sl,const String<T> &str,const T &split_char)
{
return SplitToStringList<T>(sl,str.c_str(),str.Length(),split_char);
SplitStringToStringListByChar<T> split(&sl,split_char);
return split.Split(str.c_str(),str.Length());
}
/**
* 基于指定的多个字符拆分字符串到字符串列表模板类
* 基于指定的多个字符拆分字符串到字符串列表模板类
*/
template<typename T> class SplitStringToStringListByChars:public SplitStringToStringList<T>
{
@ -313,11 +315,11 @@ namespace hgl
public:
SplitStringToStringListByChar(StringList<T> *sl,const String<T> &sc):SplitStringToStringList(sl)
SplitStringToStringListByChars(StringList<T> *sl,const String<T> &sc):SplitStringToStringList<T>(sl)
{
separator_char=sc;
}
virtual ~SplitStringToStringListByChar()=default;
virtual ~SplitStringToStringListByChars()=default;
bool isSeparatorChar(const T &ch) override
{
@ -326,37 +328,39 @@ namespace hgl
};//template<typename T,typename C> class SplitStringToStringListByChars:public SplitStringToStringList<T>
/**
* 以指定字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @param split_char 分隔字符
* @return 字符串行数
* 以指定字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @param split_char 分隔字符
* @return 字符串行数
*/
template<typename T> int SplitToStringListByChars(StringList<T> &sl,const T *str,int size,const String<T> &split_chars)
{
SplitStringToStringListByChars split(&sl,split_chars);
SplitStringToStringListByChars<T> split(&sl,split_chars);
return split.Split(str,size);
}//int SplitToStringList
template<typename T> int SplitToStringListByChars(StringList<T> &sl,const String<T> &str,const String<T> &split_chars)
{
return SplitToStringList<T>(sl,str.c_str(),str.Length(),split_chars);
SplitStringToStringListByChars<T> split(&sl,split_chars);
return split.Split(str.c_str(),str.Length());
}
/**
* 拆解一个多行字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
* 拆解一个多行字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @return 字符串行数
*/
template<typename T> int SplitToStringListByEnter(StringList<T> &sl,const T *str,int size)
{
const T sc[2]={T('\r'),T('\n')};
SplitStringToStringListByChars split(&sl,sc);
SplitStringToStringListByChars<T> split(&sl,sc);
return split.Split(str,size);
}//int SplitToStringList
@ -365,77 +369,77 @@ namespace hgl
#undef SPLIT_STRING_TO_STRING_LIST
/**
* 以指定字符为分隔拆解一个字符串到一个字符串列表
* @param sl 字符串列表处理类
* @param str 字符串
* @param size 字符串长度
* @param split_char 分隔字符
* @param maxSize 最多执行次数
* @return 字符串行数
*/
template<typename T> int SplitToStringList(StringList<T> &sl,const T *str,int size,const T &split_char,int maxSize)
{
if(!str||size<=0)return(-1);
///**
// * 以指定字符为分隔拆解一个字符串到一个字符串列表
// * @param sl 字符串列表处理类
// * @param str 字符串
// * @param size 字符串长度
// * @param split_char 分隔字符
// * @param maxSize 最多执行次数
// * @return 字符串行数
// */
//template<typename T> int SplitToStringList(StringList<T> &sl,const T *str,int size,const T &split_char,int maxSize)
//{
// if(!str||size<=0)return(-1);
int count=0;
const T *p,*sp;
// int count=0;
// const T *p,*sp;
sp=p=str;
// sp=p=str;
while(size>0)
{
if(!(*p))
{
if(p>sp)
{
sl.Add(String<T>(sp,p-sp));
++count;
}
// while(size>0)
// {
// if(!(*p))
// {
// if(p>sp)
// {
// sl.Add(String<T>(sp,p-sp));
// ++count;
// }
--size;
return count;
}
// --size;
// return count;
// }
if(*p==split_char)
{
if(p>sp)
{
sl.Add(String<T>(sp,p-sp));
++count;
}
// if(*p==split_char)
// {
// if(p>sp)
// {
// sl.Add(String<T>(sp,p-sp));
// ++count;
// }
sp=p+1; ///<跳过分割符
if(maxSize >0 && count >=maxSize-1)
{
++p;
--size;
if(size > 0)
{
sl.Add(String<T>(sp,size));
++count;
}
// sp=p+1; ///<跳过分割符
// if(maxSize >0 && count >=maxSize-1)
// {
// ++p;
// --size;
// if(size > 0)
// {
// sl.Add(String<T>(sp,size));
// ++count;
// }
return count;
}
}
// return count;
// }
// }
++p;
--size;
}
// ++p;
// --size;
// }
if(p>sp)
{
sl.Add(String<T>(sp,p-sp));
++count;
}
// if(p>sp)
// {
// sl.Add(String<T>(sp,p-sp));
// ++count;
// }
return count;
}//int SplitToStringList
// return count;
//}//int SplitToStringList
template<typename T> int SplitToStringList(StringList<T> &sl,const String<T> &str,const T &split_char,int maxSize)
{
return SplitToStringList<T>(sl,str.c_str(),str.Length(),split_char,maxSize);
}
//template<typename T> int SplitToStringList(StringList<T> &sl,const String<T> &str,const T &split_char,int maxSize)
//{
// return SplitToStringList<T>(sl,str.c_str(),str.Length(),split_char,maxSize);
//}
}//namespace hgl
#endif//HGL_SPLIT_STRING_INCLUDE
#endif//HGL_SPLIT_STRING_INCLUDE

3
inc/hgl/type/StrChar.h
View File

@ -126,7 +126,8 @@ namespace hgl
{
return((ch>='0'&&ch<='9')
||(ch>='a'&&ch<='f')
||(ch>='A'&&ch<='F'));
||(ch>='A'&&ch<='F')
||ch=='x'||ch=='X');
}
/**

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

@ -251,146 +251,5 @@ namespace hgl
DEFINE_STRING_LIST(OS)
#undef DEFINE_STRING_LIST
template<typename T,ByteOrderMask bom> struct ReadStringFromDIS
{
bool ReadString(io::DataInputStream *dis,T &str);
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF8>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF8String(str);
}
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF16LE>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF16LEString(str);
}
};
template<typename T> struct ReadStringFromDIS<T,ByteOrderMask::UTF16BE>
{
bool ReadString(io::DataInputStream *dis,T &str)
{
return dis->ReadUTF16BEString(str);
}
};
/**
* 从DataInputStream流中读取一个字符串列表
* @param sl 字符串列表处理类
* @param dis 数据输入流
* @return 字符串行数
*/
template<typename T,ByteOrderMask bom> int LoadStringList(StringList<T> &sl,io::DataInputStream *dis)
{
if(!dis)return(-1);
int count;
int result=0;
if(!dis->ReadInt32(count))
return(-2);
ReadStringFromDIS<String<T>,bom> rsfd;
String<T> str;
for(int i=0;i<count;i++)
{
if(!rsfd.ReadString(dis,str))
break;
sl.Add(str);
result++;
}
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);}
int LoadStringFromText(UTF8String & str,const void *data,const int size,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本块到UTF8StringList
int LoadStringFromText(UTF16String &str,const void *data,const int size,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本块到UTF16StringList
int LoadStringListFromText(UTF8StringList & sl,const void *data,const int size,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本块到UTF8StringList
int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本块到UTF16StringList
int LoadStringFromTextFile( UTF8String & str,const OSString &filename,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本文件到UTF8String
int LoadStringFromTextFile( UTF16String & str,const OSString &filename,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本文件到UTF16String
int LoadStringListFromTextFile( UTF8StringList & sl,const OSString &filename,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本文件到UTF8StringList
int LoadStringListFromTextFile( UTF16StringList &sl,const OSString &filename,const CharSet &default_charset=UTF8CharSet); ///<从文件加载一个文本文件到UTF16StringList
template<typename T,ByteOrderMask bom> struct WriteStringToDOS
{
bool WriteString(io::DataOutputStream *dos,const T &str);
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF8>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF8String(str);
}
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF16LE>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF16LEString(str);
}
};
template<typename T> struct WriteStringToDOS<T,ByteOrderMask::UTF16BE>
{
bool WriteString(io::DataOutputStream *dos,const T &str)
{
return dos->WriteUTF16BEString(str);
}
};
template<typename T,ByteOrderMask bom> int WriteStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
WriteStringToDOS<T,bom> wtd;
const int32 count=sl.GetCount();
int result=0;
if(!dos->WriteInt32(count))
return(-2);
for(int32 i=0;i<count;i++)
{
if(!wtd.WriteString(dos,sl[i]))
return(-3);
result++;
}
return(result);
};
template<typename T> int SaveUTF8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF8>(dos,sl);
}
template<typename T> int SaveUTF16LEStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF16LE>(dos,sl);
}
template<typename T> int SaveUTF16BEStringList(io::DataOutputStream *dos,const StringList<T> &sl)
{
return WriteStringList<T,ByteOrderMask::UTF16BE>(dos,sl);
}
}//namespace hgl
#endif//HGL_STRINGLIST_INCLUDE

6
src/CMakeLists.txt
View File

@ -60,6 +60,9 @@ SET(STRING_HEADER_FILES ${TYPE_INCLUDE_PATH}/String.h
${TYPE_INCLUDE_PATH}/StringList.h
${TYPE_INCLUDE_PATH}/SplitString.h
${TYPE_INCLUDE_PATH}/MergeString.h
${TYPE_INCLUDE_PATH}/LoadString.h
${TYPE_INCLUDE_PATH}/LoadStringList.h
${TYPE_INCLUDE_PATH}/SaveStringList.h
${TYPE_INCLUDE_PATH}/StdString.h)
SET(TEXT_HEADER_FILES ${CMCORE_ROOT_INCLUDE_PATH}/hgl/Endian.h
@ -70,7 +73,8 @@ SET(TEXT_HEADER_FILES ${CMCORE_ROOT_INCLUDE_PATH}/hgl/Endian.h
SET(TEXT_SOURCE_FILES Text/Endian.cpp
Text/CodePage.cpp
Text/UnicodeBlocks.cpp
Text/StringList.cpp)
Text/LoadString.cpp
Text/LoadStringList.cpp)
SOURCE_GROUP("Text\\String" FILES ${STRING_HEADER_FILES}
Text/StringList.cpp)

56
src/Text/StringList.cpp → src/Text/LoadString.cpp
View File

@ -1,4 +1,4 @@
#include<hgl/type/StringList.h>
#include<hgl/type/LoadString.h>
#include<hgl/filesystem/FileSystem.h>
namespace hgl
{
@ -158,30 +158,6 @@ namespace hgl
return char_count;
}
/**
* 加载一个原始文本块到UTF8StringList
*/
int LoadStringListFromText(UTF8StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF8String str;
LoadStringFromText(str,data,size,cs);
return SplitToStringListByEnter<u8char>(sl,str);
}
/**
* 加载一个原始文本块到UTF16StringList
*/
int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF16String str;
LoadStringFromText(str,data,size,cs);
return SplitToStringListByEnter<u16char>(sl,str);
}
/**
* 加载一个原始文本文件到UTF8String
*/
@ -211,34 +187,4 @@ namespace hgl
return LoadStringFromText(str,data,size,cs);
}
/**
* 加载一个原始文本文件到UTF8StringList
*/
int LoadStringListFromTextFile(UTF8StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;
const int size=filesystem::LoadFileToMemory(filename,(void **)&data);
if(size<=0)
return size;
return LoadStringListFromText(sl,data,size,cs);
}
/**
* 加载一个原始文本文件到UTF16StringList
*/
int LoadStringListFromTextFile(UTF16StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;
const int size=filesystem::LoadFileToMemory(filename,(void **)&data);
if(size<=0)
return size;
return LoadStringListFromText(sl,data,size,cs);
}
}//namespace hgl

61
src/Text/LoadStringList.cpp Normal file
View File

@ -0,0 +1,61 @@
#include<hgl/type/LoadStringList.h>
#include<hgl/type/LoadString.h>
#include<hgl/type/SplitString.h>
#include<hgl/filesystem/FileSystem.h>
namespace hgl
{
/**
* 加载一个原始文本块到UTF8StringList
*/
int LoadStringListFromText(UTF8StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF8String str;
LoadStringFromText(str,data,size,cs);
return SplitToStringListByEnter<u8char>(sl,str);
}
/**
* 加载一个原始文本块到UTF16StringList
*/
int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &cs)
{
UTF16String str;
LoadStringFromText(str,data,size,cs);
return SplitToStringListByEnter<u16char>(sl,str);
}
/**
* 加载一个原始文本文件到UTF8StringList
*/
int LoadStringListFromTextFile(UTF8StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;
const int size=filesystem::LoadFileToMemory(filename,(void **)&data);
if(size<=0)
return size;
return LoadStringListFromText(sl,data,size,cs);
}
/**
* 加载一个原始文本文件到UTF16StringList
*/
int LoadStringListFromTextFile(UTF16StringList &sl,const OSString &filename,const CharSet &cs)
{
uchar *data;
const int size=filesystem::LoadFileToMemory(filename,(void **)&data);
if(size<=0)
return size;
return LoadStringListFromText(sl,data,size,cs);
}
}//namespace hgl