sql_string.h
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:6k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17. /* This file is originally from the mysql distribution. Coded by monty */
  18. #ifdef __GNUC__
  19. #pragma interface /* gcc class implementation */
  20. #endif
  21. #ifndef NOT_FIXED_DEC
  22. #define NOT_FIXED_DEC 31
  23. #endif
  24. class String
  25. {
  26.   char *Ptr;
  27.   uint32 str_length,Alloced_length;
  28.   bool alloced;
  29. public:
  30.   String()
  31.   { Ptr=0; str_length=Alloced_length=0; alloced=0; }
  32.   String(uint32 length_arg)
  33.   { alloced=0; Alloced_length=0; (void) real_alloc(length_arg); }
  34.   String(const char *str)
  35.   { Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;}
  36.   String(const char *str,uint32 len)
  37.   { Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;}
  38.   String(char *str,uint32 len)
  39.   { Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;}
  40.   String(const String &str)
  41.   { Ptr=str.Ptr ; str_length=str.str_length ;
  42.     Alloced_length=str.Alloced_length; alloced=0; }
  43.   static void *operator new(size_t size) { return (void*) sql_alloc((uint) size); }
  44.   static void operator delete(void *ptr_arg,size_t size) /*lint -e715 */
  45.     { sql_element_free(ptr_arg); }
  46.   ~String() { free(); }
  47.   inline uint32 length() const { return str_length;}
  48.   inline uint32 alloced_length() const { return Alloced_length;}
  49.   inline char& operator [] (uint32 i) const { return Ptr[i]; }
  50.   inline void length(uint32 len) { str_length=len ; }
  51.   inline bool is_empty() { return (str_length == 0); }
  52.   inline const char *ptr() const { return Ptr; }
  53.   inline char *c_ptr()
  54.   {
  55.     if (!Ptr || Ptr[str_length]) /* Should be safe */
  56.       (void) realloc(str_length);
  57.     return Ptr;
  58.   }
  59.   inline char *c_ptr_quick()
  60.   {
  61.     if (Ptr && str_length < Alloced_length)
  62.       Ptr[str_length]=0;
  63.     return Ptr;
  64.   }
  65.   void set(String &str,uint32 offset,uint32 arg_length)
  66.   {
  67.     free();
  68.     Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0;
  69.     if (str.Alloced_length)
  70.       Alloced_length=str.Alloced_length-offset;
  71.     else
  72.       Alloced_length=0;
  73.   }
  74.   inline void set(char *str,uint32 arg_length)
  75.   {
  76.     free();
  77.     Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
  78.   }
  79.   inline void set(const char *str,uint32 arg_length)
  80.   {
  81.     free();
  82.     Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
  83.   }
  84.   inline void set_quick(char *str,uint32 arg_length)
  85.   {
  86.     if (!alloced)
  87.     {
  88.       Ptr=(char*) str; str_length=Alloced_length=arg_length;
  89.     }
  90.   }
  91.   bool set(longlong num);
  92.   /* bool set(long num); */
  93.   bool set(ulonglong num);
  94.   bool set(double num,uint decimals=2);
  95.   inline void free()
  96.   {
  97.     if (alloced)
  98.     {
  99.       alloced=0;
  100.       Alloced_length=0;
  101.       my_free(Ptr,MYF(0));
  102.       Ptr=0;
  103.       str_length=0; /* Safety */
  104.     }
  105.   }
  106.   inline bool alloc(uint32 arg_length)
  107.   {
  108.     if (arg_length < Alloced_length)
  109.       return 0;
  110.     return real_alloc(arg_length);
  111.   }
  112.   bool real_alloc(uint32 arg_length); // Empties old string
  113.   bool realloc(uint32 arg_length);
  114.   inline void shrink(uint32 arg_length) // Shrink buffer
  115.   {
  116.     if (arg_length < Alloced_length)
  117.     {
  118.       char *new_ptr;
  119.       if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
  120.       {
  121. (void) my_free(Ptr,MYF(0));
  122. real_alloc(arg_length);
  123.       }
  124.       else
  125.       {
  126. Ptr=new_ptr;
  127. Alloced_length=arg_length;
  128.       }
  129.     }
  130.   }
  131.   bool is_alloced() { return alloced; }
  132.   inline String& operator = (const String &s)
  133.   {
  134.     if (&s != this)
  135.     {
  136.       free();
  137.       Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
  138.       alloced=0;
  139.     }
  140.     return *this;
  141.   }
  142.   bool copy(); // Alloc string if not alloced
  143.   bool copy(const String &s); // Allocate new string
  144.   bool copy(const char *s,uint32 arg_length); // Allocate new string
  145.   bool append(const String &s);
  146.   bool append(const char *s,uint32 arg_length=0);
  147.   bool append(IO_CACHE* file, uint32 arg_length);
  148.   int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  149.   int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  150.   bool replace(uint32 offset,uint32 arg_length,const String &to);
  151.   inline bool append(char chr)
  152.   {
  153.     if (str_length < Alloced_length)
  154.     {
  155.       Ptr[str_length++]=chr;
  156.     }
  157.     else
  158.     {
  159.       if (realloc(str_length+1))
  160. return 1;
  161.       Ptr[str_length++]=chr;
  162.     }
  163.     return 0;
  164.   }
  165.   bool fill(uint32 max_length,char fill);
  166.   void strip_sp();
  167.   inline void caseup() { ::caseup(Ptr,str_length); }
  168.   inline void casedn() { ::casedn(Ptr,str_length); }
  169.   friend int sortcmp(const String *a,const String *b);
  170.   friend int stringcmp(const String *a,const String *b);
  171.   friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  172.   friend int wild_case_compare(String &match,String &wild,char escape);
  173.   friend int wild_compare(String &match,String &wild,char escape);
  174.   uint32 numchars();
  175.   int charpos(int i,uint32 offset=0);
  176. };