SourceForge.jp

dkutilString.h

説明を見る。
00001 
00002 #ifndef _dkutilString__
00003 #define _dkutilString__
00004 
00005 
00006 #include "dkutilDefined.h"
00007 //まだまだテスト中なので・・・ 使わんといてください。
00008 //完全VC依存だな・・・
00009 
00010 namespace dkutil{
00011 #if 0
00012     /*
00013 template<size_t s>
00014 class char_array{
00015 protected:
00016     char str[s];
00017     enum{
00018         enuSize=s;
00019     };
00020 public:
00021     
00022     char_array(){::memset(str,0,sizeof(str));}
00023     virtual ~char_array(){}
00024     char *get(){return str;}
00025     void set(char *p,size_t s){
00026         if(
00027         ::memcpy(str,p,s);
00028         }
00029 */
00030     
00031     
00032 template<class T>
00033 class dkbasic_string{
00034 public:
00035     typedef size_t size_type;
00036 protected:
00037     T *m_str;
00038     size_type m_size;
00039 public:
00040     dkbasic_string(){
00041         m_str=NULL;
00042         m_size = 0;
00043     }
00044     virtual ~dkbasic_string(){}
00045     T *get_str(){return m_str;}
00046     void set_str(T *str){
00047         size_type size = _tcslen(str);
00048         if(size >= m_size){
00049             DK_THROW(std::overflow_error("set_str overflow"));
00050             return;
00051         }
00052         ::memcpy(m_str,str,size);
00053     }
00054     void allocate_str(size_type size){
00055         if(!m_str){
00056             m_str = malloc(size);
00057 
00058 
00059 
00060 class dkstring : {
00061 protected:
00062     
00063     char *get_str(){return c_str();
00064 
00065         
00066 #endif
00067 
00068 
00069 
00070 
00071 
00072 #if defined(jms1) || defined(jms2)
00073 #   error please undef jms1 and jms2
00074 #endif
00075 
00076 #define jms1(c) (((((unsigned char)(c))>=0x81)&&(((unsigned char)(c))<=0x9F))||((((unsigned char)(c))>=0xE0)&&(((unsigned char)(c))<=0xFC)))
00077 #define jms2(c) ((((unsigned char)(c))!=0x7F)&&(((unsigned char)(c))>=0x40)&&(((unsigned char)(c))<=0xFC))
00078 
00079 
00090 inline int isShiftJIS( const char *str, int nPos )
00091 {
00092     int i;
00093     int state; // { 0, 1, 2 } = { 1バイト文字, 2バイト文字の第1バイト, 2バイト文字の第2バイト }
00094 
00095     state = 0;
00096     for( i = 0; str[i] != '\0'; i++ )
00097     {
00098         if      ( ( state == 0 ) && ( jms1( str[i] ) ) ) state = 1; // 0 -> 1
00099         else if ( ( state == 1 ) && ( jms2( str[i] ) ) ) state = 2; // 1 -> 2
00100         else if ( ( state == 2 ) && ( jms1( str[i] ) ) ) state = 1; // 2 -> 1
00101         else                                             state = 0; // 2 -> 0, その他
00102 
00103         // str[nPos] での状態を返す。
00104         if ( i == nPos ) return state;
00105     }
00106     return 0;
00107 }//isShiftJIS
00108 
00109 #undef jms1
00110 #undef jms2
00111 
00113 inline int isJMS(const char *str,int nPos){
00114     return isShiftJIS(str,nPos);
00115 }
00116 
00117 
00118 
00120 inline char *strtail( const char *stringg )
00121 {
00122     return ::strchr( stringg, '\0' );
00123 }//strtail
00124 
00125 
00127 inline bool isSpace(char lp){
00128     if(!(lp=='\0' || lp==0x0a || lp==0x0d || lp==' ' || lp=='\t')){
00129         return false;
00130     }
00131     return true;
00132 }
00133 
00135 inline bool isVisible(char v){
00136     if((0x21 > v && 0x7E < v)){
00137         return false;
00138     }
00139     return true;
00140 }
00141 
00142 
00143 inline bool isDigit(int c){
00144     if(::isdigit(c)){return true;}
00145     return false;
00146 }
00147 inline bool isAlpha(int c){
00148     if(::isalpha(c)){return true;}
00149     return false;
00150 }
00152 inline bool isHex(int c){
00153     if(isDigit(c)){ return true;}
00154 
00155     if(('A' <= c && c <= 'F') || ('a' <= c && c <= 'f')){
00156         return true;
00157     }
00158     return false;
00159 }
00160     
00161     
00162 
00163 inline ULONGLONG atoull(const char *a){
00164     const char *b = a;
00165     ULONGLONG ret;
00166     size_t maxlen = strlen(ULONGLONG_MAX_STR);
00167     ret = 0;
00168     
00169     for (size_t i=0;;a++,i++)
00170     {
00171         if(!isDigit((*a))){
00172             throw std::invalid_argument("文字列が混じっていたぞ!");
00173         }
00174         if(maxlen < i){
00175             throw std::overflow_error("オーバーフローしちまったぞ!よって戻り値はアホ値だ!");
00176         }
00177         switch (*a)
00178         {
00179         case '\0':
00180             return ret;
00181 
00182         case '0': case '1': case '2': case '3':
00183         case '4': case '5': case '6': case '7':
00184         case '8': case '9':
00185             ret *= 10;
00186             ret += (*a) - '0';
00187             break;
00188         }
00189     }
00190     return 0;
00191 }
00198 
00199 inline int toTolower(char *dest,size_t size1,const char *src,size_t srclen){
00200     if(size1 <= srclen){
00201         for(size_t i=0;i<size1;i++){
00202             dest[i] = tolower(src[i]);
00203         }
00204         //::strncpy(dest,src,size1);
00205         dest[size1 - 1] = '\0';
00206         return edk_Not_Satisfactory;
00207     }else{
00208         for(size_t i=0;i<srclen;i++){
00209             dest[i] = tolower(src[i]);
00210         }
00211         dest[srclen] = '\0';
00212         return edk_SUCCEEDED;
00213     }
00214 }
00215 
00216 #ifdef UNICODE
00217 #   error "多分、UNICODEだとradix_convertはエラーするでしょう。"
00218 #endif
00219 class radix_convert{
00220 public://MessageBox
00221 
00222 #define RADIX_CONVERT_LOCAL(R){\
00223         const char enuCTOI_CHECK=48;\
00224         const char enuCTOI16_LOWER=97;\
00225         const char enuCTOI16_WUPPER=65;\
00226         const char *begin = s;\
00227         R ret;\
00228         ret = 0;\
00229         s = s+2;\
00230         register int i=strlen(s) - 1;\
00231         while(*s){\
00232             R tmp;\
00233             if('0'<=(*s) && '9' >= (*s))\
00234             {\
00235                 tmp = static_cast<R>(pow(16,i));\
00236                 ret += ((*s) - enuCTOI_CHECK) * tmp;\
00237             }else{\
00238                 tmp = static_cast<R>(pow(16,i));\
00239                 if(iswupper(*s))\
00240                 {\
00241                     ret += ((*s) - enuCTOI16_WUPPER + 10) * tmp;\
00242                 }else{\
00243                     ret += ((*s) - enuCTOI16_LOWER + 10) * tmp;\
00244                 }\
00245             }\
00246             s++;\
00247             i--;\
00248         }\
00249         return ret;\
00250     }
00251     inline ULONGLONG a16toull(const char *s){
00252         RADIX_CONVERT_LOCAL(ULONGLONG)
00253     }
00254     inline UINT a16toui(const char *s){
00255         RADIX_CONVERT_LOCAL(UINT)
00256     }
00257     inline INT a16toi(const char *s){
00258         RADIX_CONVERT_LOCAL(INT)
00259     }
00260     inline LONGLONG a16toll(const char *s){
00261         RADIX_CONVERT_LOCAL(LONGLONG)
00262     }
00263 };
00264 
00265 
00266 template<class FUNC>
00267 inline bool isStringBase(const char *str,FUNC func)
00268 {
00269     size_t len = strlen(str);
00270     for(size_t i=0;i<len;i++){
00271         if(!func(str[i])) return false;
00272     }
00273     return true;
00274 }
00275 
00276 inline bool isStringDigit(const char *str){
00277     return isStringBase(str,isDigit);
00278 }
00279 
00280 inline bool isStringAlpha(const char *str){
00281     return isStringBase(str,isAlpha);
00282 }
00283 
00285 inline bool isStringHex(const char *s){
00286     size_t size=strlen(s);
00287     size_t begin = 0;
00288     if(size <= 1){ return isDigit(*s);}
00289 
00290     if('0' == s[0] && 'x' == s[1]){
00291         begin = 2;
00292     }
00293     for(size_t i=begin;i<size;i++){
00294         if(!isHex(s[i])) return false;
00295     }
00296     return true;
00297 }
00298     
00299 
00300 
00301 
00302 
00307 extern bool isBigStrNum(char *src,char *str);
00308 
00309 
00310 namespace private_{
00311 
00314 struct GetStringToIntLengthTypeBase{
00315     typedef size_t size_type;
00316 private:
00317     size_type strint;
00318     size_type struint;
00319     size_type strlonglong;
00320     size_type strulonglong;
00321 public:
00322     GetStringToIntLengthTypeBase(){
00323         strint = strlen(INT_MAX_STR);
00324         struint = strlen(UINT_MAX_STR);
00325         strlonglong = strlen(LONGLONG_MAX_STR);
00326         strulonglong = strlen(ULONGLONG_MAX_STR);
00327     }
00328     //virtual ~GetStringToIntLengthTypeBase(){}
00329     int operator ()(const char *s);
00330         
00331 };
00332 
00333 
00334 
00335 
00336 }//end of private_ namespace
00337 
00338 extern int GetStringToIntLengthType(const char *s);
00339 
00340 
00342 inline std::string to_string(int i){
00343     char buff[64]="";
00344     itoa(i,buff,10);
00345     return std::string(buff);
00346 }
00348 inline std::string to_string(double d){
00349     char buff[256]="";
00350     dksprintf(buff,sizeof(buff),"%f",d);
00351     return std::string(buff);
00352 }
00353 
00354 
00355 
00356 }//end of dkutil namespace
00357 
00358 
00359 #ifndef _MSC_VER
00360 inline LONGLONG _atoi64(const char *a){
00361     const char *b = a;
00362     LONGLONG ret;
00363     size_t maxlen = strlen(LONGLONG_MAX_STR);
00364     ret = 0;
00365     
00366     for (size_t i=0;;a++,i++)
00367     {
00368         if(!dkutil::isDigit((*a))){
00369             throw std::invalid_argument("文字列が混じっていたぞ!");
00370         }
00371         if(maxlen < i){
00372             throw std::overflow_error("オーバーフローしちまったぞ!よって戻り値はアホ値だ!");
00373         }
00374         switch (*a)
00375         {
00376         case '\0':
00377             return ret;
00378 
00379         case '0': case '1': case '2': case '3':
00380         case '4': case '5': case '6': case '7':
00381         case '8': case '9':
00382             ret *= 10;
00383             ret += (*a) - '0';
00384             break;
00385         }
00386     }
00387     return 0;
00388 }
00389 #endif
00390 
00391 
00392 #endif//end of include once

dkutil 1.02リリース前 d金魚専用マニュアルバージョンに対してSun Dec 28 21:23:08 2003に生成されました。 doxygen 1.3.5