home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / client / sql_string.h < prev   
C/C++ Source or Header  |  2000-11-16  |  6KB  |  185 lines
  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.  
  18. /* This file is originally from the mysql distribution. Coded by monty */
  19.  
  20. #ifdef __GNUC__
  21. #pragma interface            /* gcc class implementation */
  22. #endif
  23.  
  24. #ifndef NOT_FIXED_DEC
  25. #define NOT_FIXED_DEC            31
  26. #endif
  27.  
  28. class String
  29. {
  30.   char *Ptr;
  31.   uint32 str_length,Alloced_length;
  32.   bool alloced;
  33. public:
  34.   String()
  35.   { Ptr=0; str_length=Alloced_length=0; alloced=0; }
  36.   String(uint32 length_arg)
  37.   { alloced=0; Alloced_length=0; (void) real_alloc(length_arg); }
  38.   String(const char *str)
  39.   { Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;}
  40.   String(const char *str,uint32 len)
  41.   { Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;}
  42.   String(char *str,uint32 len)
  43.   { Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;}
  44.   String(const String &str)
  45.   { Ptr=str.Ptr ; str_length=str.str_length ;
  46.     Alloced_length=str.Alloced_length; alloced=0; }
  47.  
  48.   static void *operator new(size_t size) { return (void*) sql_alloc((uint) size); }
  49.   static void operator delete(void *ptr_arg,size_t size) /*lint -e715 */
  50.     { sql_element_free(ptr_arg); }
  51.   ~String() { free(); }
  52.  
  53.   inline uint32 length() const { return str_length;}
  54.   inline uint32 alloced_length() const { return Alloced_length;}
  55.   inline char& operator [] (uint32 i) const { return Ptr[i]; }
  56.   inline void length(uint32 len) { str_length=len ; }
  57.   inline bool is_empty() { return (str_length == 0); }
  58.   inline const char *ptr() const { return Ptr; }
  59.   inline char *c_ptr()
  60.   {
  61.     if (!Ptr || Ptr[str_length])        /* Should be safe */
  62.       (void) realloc(str_length);
  63.     return Ptr;
  64.   }
  65.   inline char *c_ptr_quick()
  66.   {
  67.     if (Ptr && str_length < Alloced_length)
  68.       Ptr[str_length]=0;
  69.     return Ptr;
  70.   }
  71.  
  72.   void set(String &str,uint32 offset,uint32 arg_length)
  73.   {
  74.     free();
  75.     Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0;
  76.     if (str.Alloced_length)
  77.       Alloced_length=str.Alloced_length-offset;
  78.     else
  79.       Alloced_length=0;
  80.   }
  81.   inline void set(char *str,uint32 arg_length)
  82.   {
  83.     free();
  84.     Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
  85.   }
  86.   inline void set(const char *str,uint32 arg_length)
  87.   {
  88.     free();
  89.     Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
  90.   }
  91.   inline void set_quick(char *str,uint32 arg_length)
  92.   {
  93.     if (!alloced)
  94.     {
  95.       Ptr=(char*) str; str_length=Alloced_length=arg_length;
  96.     }
  97.   }
  98.   bool set(longlong num);
  99.   /* bool set(long num); */
  100.   bool set(ulonglong num);
  101.   bool set(double num,uint decimals=2);
  102.   inline void free()
  103.   {
  104.     if (alloced)
  105.     {
  106.       alloced=0;
  107.       Alloced_length=0;
  108.       my_free(Ptr,MYF(0));
  109.       Ptr=0;
  110.       str_length=0;                /* Safety */
  111.     }
  112.   }
  113.   inline bool alloc(uint32 arg_length)
  114.   {
  115.     if (arg_length < Alloced_length)
  116.       return 0;
  117.     return real_alloc(arg_length);
  118.   }
  119.   bool real_alloc(uint32 arg_length);            // Empties old string
  120.   bool realloc(uint32 arg_length);
  121.   inline void shrink(uint32 arg_length)        // Shrink buffer
  122.   {
  123.     if (arg_length < Alloced_length)
  124.     {
  125.       char *new_ptr;
  126.       if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
  127.       {
  128.     (void) my_free(Ptr,MYF(0));
  129.     real_alloc(arg_length);
  130.       }
  131.       else
  132.       {
  133.     Ptr=new_ptr;
  134.     Alloced_length=arg_length;
  135.       }
  136.     }
  137.   }
  138.   bool is_alloced() { return alloced; }
  139.   inline String& operator = (const String &s)
  140.   {
  141.     if (&s != this)
  142.     {
  143.       free();
  144.       Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
  145.       alloced=0;
  146.     }
  147.     return *this;
  148.   }
  149.  
  150.   bool copy();                    // Alloc string if not alloced
  151.   bool copy(const String &s);            // Allocate new string
  152.   bool copy(const char *s,uint32 arg_length);    // Allocate new string
  153.   bool append(const String &s);
  154.   bool append(const char *s,uint32 arg_length=0);
  155.   bool append(IO_CACHE* file, uint32 arg_length);
  156.   int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  157.   int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  158.   bool replace(uint32 offset,uint32 arg_length,const String &to);
  159.   inline bool append(char chr)
  160.   {
  161.     if (str_length < Alloced_length)
  162.     {
  163.       Ptr[str_length++]=chr;
  164.     }
  165.     else
  166.     {
  167.       if (realloc(str_length+1))
  168.     return 1;
  169.       Ptr[str_length++]=chr;
  170.     }
  171.     return 0;
  172.   }
  173.   bool fill(uint32 max_length,char fill);
  174.   void strip_sp();
  175.   inline void caseup() { ::caseup(Ptr,str_length); }
  176.   inline void casedn() { ::casedn(Ptr,str_length); }
  177.   friend int sortcmp(const String *a,const String *b);
  178.   friend int stringcmp(const String *a,const String *b);
  179.   friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  180.   friend int wild_case_compare(String &match,String &wild,char escape);
  181.   friend int wild_compare(String &match,String &wild,char escape);
  182.   uint32 numchars();
  183.   int charpos(int i,uint32 offset=0);
  184. };
  185.