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

inc/hgl/type/LoadString.h

@@ -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

inc/hgl/type/LoadStringList.h

@@ -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

inc/hgl/type/MergeString.h

@@ -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 sl 要整合的字符串列表
-     * @param end_line 换行符
+     * @param end_line 换行符
-     * @return 字符串
+     * @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

inc/hgl/type/SaveStringList.h

@@ -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

inc/hgl/type/SplitString.h

@@ -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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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进制数字串到一个字符串列表
+     * 拆分16进制数字串到一个字符串列表
-     * @param sl 字符串列表处理类
+     * @param sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @param split_char 分隔字符
+     * @param split_char 分隔字符
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @param split_char 分隔字符
+     * @param split_char 分隔字符
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+     * @param str 字符串
-     * @param size 字符串长度
+     * @param size 字符串长度
-     * @return 字符串行数
+     * @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 sl 字符串列表处理类
-     * @param str 字符串
+    // * @param str 字符串
-     * @param size 字符串长度
+    // * @param size 字符串长度
-     * @param split_char 分隔字符
+    // * @param split_char 分隔字符
-     * @param maxSize 最多执行次数
+    // * @param maxSize 最多执行次数
-     * @return 字符串行数
+    // * @return 字符串行数
-     */
+    // */
-    template<typename T> int SplitToStringList(StringList<T> &sl,const T *str,int size,const T &split_char,int maxSize)
+    //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);
+    //    if(!str||size<=0)return(-1);
 
-        int count=0;
+    //    int count=0;
-        const T *p,*sp;
+    //    const T *p,*sp;
 
-        sp=p=str;
+    //    sp=p=str;
 
-        while(size>0)
+    //    while(size>0)
-        {
+    //    {
-            if(!(*p))
+    //        if(!(*p))
-            {
+    //        {
-                if(p>sp)
+    //            if(p>sp)
-                {
+    //            {
-                    sl.Add(String<T>(sp,p-sp));
+    //                sl.Add(String<T>(sp,p-sp));
-                    ++count;
+    //                ++count;
-                }
+    //            }
 
-                --size;
+    //            --size;
-                return count;
+    //            return count;
-            }
+    //        }
 
-            if(*p==split_char)
+    //        if(*p==split_char)
-            {
+    //        {
-                if(p>sp)
+    //            if(p>sp)
-                {
+    //            {
-                    sl.Add(String<T>(sp,p-sp));
+    //                sl.Add(String<T>(sp,p-sp));
-                    ++count;
+    //                ++count;
-                }
+    //            }
 
-                sp=p+1; ///<跳过分割符
+    //            sp=p+1; ///<跳过分割符
-                if(maxSize >0 && count >=maxSize-1)
+    //            if(maxSize >0 && count >=maxSize-1)
-                {
+    //            {
-                    ++p;
+    //                ++p;
-                    --size;
+    //                --size;
-                    if(size > 0)
+    //                if(size > 0)
-                    {
+    //                {
-                        sl.Add(String<T>(sp,size));
+    //                    sl.Add(String<T>(sp,size));
-                        ++count;
+    //                    ++count;
-                    }
+    //                }
 
-                    return count;
+    //                return count;
-                }
+    //            }
-            }
+    //        }
 
-            ++p;
+    //        ++p;
-            --size;
+    //        --size;
-        }
+    //    }
 
-        if(p>sp)
+    //    if(p>sp)
-        {
+    //    {
-            sl.Add(String<T>(sp,p-sp));
+    //        sl.Add(String<T>(sp,p-sp));
-            ++count;
+    //        ++count;
-        }
+    //    }
 
-        return count;
+    //    return count;
-    }//int SplitToStringList
+    //}//int SplitToStringList
 
-    template<typename T> int SplitToStringList(StringList<T> &sl,const String<T> &str,const T &split_char,int 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);
+    //    return SplitToStringList<T>(sl,str.c_str(),str.Length(),split_char,maxSize);
-    }
+    //}
 }//namespace hgl
-#endif//HGL_SPLIT_STRING_INCLUDE
+#endif//HGL_SPLIT_STRING_INCLUDE

inc/hgl/type/StrChar.h

@@ -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');
     }
 
     /**

inc/hgl/type/StringList.h

@@ -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

src/CMakeLists.txt

@@ -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)

src/Text/LoadString.cpp

@@ -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

src/Text/LoadStringList.cpp

@@ -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