sql_string.h 7.21 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4 5 6 7 8
/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
unknown's avatar
unknown committed
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
unknown's avatar
unknown committed
10 11 12 13 14 15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
unknown's avatar
unknown committed
16 17 18 19 20 21 22 23 24 25 26

/* This file is originally from the mysql distribution. Coded by monty */

#ifdef __GNUC__
#pragma interface			/* gcc class implementation */
#endif

#ifndef NOT_FIXED_DEC
#define NOT_FIXED_DEC			31
#endif

27 28 29 30 31 32 33
class String;
int sortcmp(const String *a,const String *b);
int stringcmp(const String *a,const String *b);
String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
int wild_case_compare(String &match,String &wild,char escape);
int wild_compare(String &match,String &wild,char escape);

unknown's avatar
unknown committed
34 35 36 37 38
class String
{
  char *Ptr;
  uint32 str_length,Alloced_length;
  bool alloced;
39
  CHARSET_INFO *str_charset;
unknown's avatar
unknown committed
40 41
public:
  String()
42 43 44 45
  { 
    Ptr=0; str_length=Alloced_length=0; alloced=0; 
    str_charset=default_charset_info; 
  }
unknown's avatar
unknown committed
46
  String(uint32 length_arg)
47 48 49 50
  { 
    alloced=0; Alloced_length=0; (void) real_alloc(length_arg); 
    str_charset=default_charset_info;  
  }
unknown's avatar
unknown committed
51
  String(const char *str)
52 53 54 55
  { 
    Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;
    str_charset=default_charset_info;
  }
unknown's avatar
unknown committed
56
  String(const char *str,uint32 len)
57 58 59 60
  { 
    Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;
    str_charset=default_charset_info;  
  }
unknown's avatar
unknown committed
61
  String(char *str,uint32 len)
62 63 64 65
  { 
    Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;
    str_charset=default_charset_info;
  }
unknown's avatar
unknown committed
66
  String(const String &str)
67 68 69 70 71
  { 
    Ptr=str.Ptr ; str_length=str.str_length ;
    Alloced_length=str.Alloced_length; alloced=0; 
    str_charset=str.str_charset;
  }
unknown's avatar
unknown committed
72
  static void *operator new(size_t size) { return (void*) sql_alloc((uint) size); }
unknown's avatar
unknown committed
73 74 75 76
  static void operator delete(void *ptr_arg,size_t size) /*lint -e715 */
    { sql_element_free(ptr_arg); }
  ~String() { free(); }

77
  inline CHARSET_INFO *charset() const { return str_charset; }
unknown's avatar
unknown committed
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
  inline uint32 length() const { return str_length;}
  inline uint32 alloced_length() const { return Alloced_length;}
  inline char& operator [] (uint32 i) const { return Ptr[i]; }
  inline void length(uint32 len) { str_length=len ; }
  inline bool is_empty() { return (str_length == 0); }
  inline const char *ptr() const { return Ptr; }
  inline char *c_ptr()
  {
    if (!Ptr || Ptr[str_length])		/* Should be safe */
      (void) realloc(str_length);
    return Ptr;
  }
  inline char *c_ptr_quick()
  {
    if (Ptr && str_length < Alloced_length)
      Ptr[str_length]=0;
    return Ptr;
  }

  void set(String &str,uint32 offset,uint32 arg_length)
  {
    free();
    Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0;
    if (str.Alloced_length)
      Alloced_length=str.Alloced_length-offset;
    else
      Alloced_length=0;
  }
  inline void set(char *str,uint32 arg_length)
  {
    free();
    Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
  }
  inline void set(const char *str,uint32 arg_length)
  {
    free();
    Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
  }
  inline void set_quick(char *str,uint32 arg_length)
  {
    if (!alloced)
    {
      Ptr=(char*) str; str_length=Alloced_length=arg_length;
    }
  }
  bool set(longlong num);
  /* bool set(long num); */
  bool set(ulonglong num);
  bool set(double num,uint decimals=2);
  inline void free()
128 129
  {
    if (alloced)
unknown's avatar
unknown committed
130
    {
131 132 133 134 135
      alloced=0;
      Alloced_length=0;
      my_free(Ptr,MYF(0));
      Ptr=0;
      str_length=0;				/* Safety */
unknown's avatar
unknown committed
136
    }
137
  }
unknown's avatar
unknown committed
138 139 140 141 142 143 144 145 146 147 148 149 150
  inline bool alloc(uint32 arg_length)
  {
    if (arg_length < Alloced_length)
      return 0;
    return real_alloc(arg_length);
  }
  bool real_alloc(uint32 arg_length);			// Empties old string
  bool realloc(uint32 arg_length);
  inline void shrink(uint32 arg_length)		// Shrink buffer
  {
    if (arg_length < Alloced_length)
    {
      char *new_ptr;
unknown's avatar
unknown committed
151
      if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
unknown's avatar
unknown committed
152
      {
153
	Alloced_length = 0;
unknown's avatar
unknown committed
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
	real_alloc(arg_length);
      }
      else
      {
	Ptr=new_ptr;
	Alloced_length=arg_length;
      }
    }
  }
  bool is_alloced() { return alloced; }
  inline String& operator = (const String &s)
  {
    if (&s != this)
    {
      free();
      Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
      alloced=0;
    }
    return *this;
  }

  bool copy();					// Alloc string if not alloced
  bool copy(const String &s);			// Allocate new string
  bool copy(const char *s,uint32 arg_length);	// Allocate new string
  bool append(const String &s);
  bool append(const char *s,uint32 arg_length=0);
180
  bool append(IO_CACHE* file, uint32 arg_length);
unknown's avatar
unknown committed
181
  int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
182
  int strstr_case(const String &s,uint32 offset=0);
unknown's avatar
unknown committed
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
  int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  bool replace(uint32 offset,uint32 arg_length,const String &to);
  inline bool append(char chr)
  {
    if (str_length < Alloced_length)
    {
      Ptr[str_length++]=chr;
    }
    else
    {
      if (realloc(str_length+1))
	return 1;
      Ptr[str_length++]=chr;
    }
    return 0;
  }
  bool fill(uint32 max_length,char fill);
  void strip_sp();
201 202
  inline void caseup() { my_caseup(str_charset,Ptr,str_length); }
  inline void casedn() { my_casedn(str_charset,Ptr,str_length); }
unknown's avatar
unknown committed
203 204 205 206 207 208 209
  friend int sortcmp(const String *a,const String *b);
  friend int stringcmp(const String *a,const String *b);
  friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  friend int wild_case_compare(String &match,String &wild,char escape);
  friend int wild_compare(String &match,String &wild,char escape);
  uint32 numchars();
  int charpos(int i,uint32 offset=0);
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254

// added by Holyfoot for "geometry" needs
  int reserve(uint32 space_needed)
  {
    return realloc(str_length + space_needed);
  }
  int reserve(uint32 space_needed, uint32 grow_by);

// these append operations do NOT check alloced memory
// q_*** methods writes values of parameters itself
// qs_*** methods writes string representation of value
  void q_append(const char &c)
  {
    Ptr[str_length++] = c;
  }
  void q_append(const uint32 &n)
  {
    int4store(Ptr + str_length, n);
    str_length += 4;
  }
  void q_append(double d)
  {
    float8store(Ptr + str_length, d);
    str_length += 8;
  }
  void q_append(double *d)
  {
    float8store(Ptr + str_length, *d);
    str_length += 8;
  }
  void q_append(const char *data, uint32 data_len)
  {
    memcpy(Ptr + str_length, data, data_len);
    str_length += data_len;
  }

  void WriteAtPosition(int position, uint32 value)
  {
    int4store(Ptr + position,value);
  }

  void qs_append(const char *str);
  void qs_append(double d);
  void qs_append(double *d);
  void qs_append(const char &c);
unknown's avatar
unknown committed
255
};