sql_string.h 8.1 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
class String;
28
int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
29 30
String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);

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

unknown's avatar
unknown committed
74
  inline void set_charset(CHARSET_INFO *charset) { str_charset= charset; }
75
  inline CHARSET_INFO *charset() const { return str_charset; }
unknown's avatar
unknown committed
76 77 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
  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;
103
    str_charset=str.str_charset;
unknown's avatar
unknown committed
104
  }
105
  inline void set(char *str,uint32 arg_length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
106 107 108
  {
    free();
    Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
109
    str_charset=cs;
unknown's avatar
unknown committed
110
  }
111
  inline void set(const char *str,uint32 arg_length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
112 113 114
  {
    free();
    Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
115
    str_charset=cs;
unknown's avatar
unknown committed
116
  }
unknown's avatar
unknown committed
117
  bool set_latin1(const char *str, uint32 arg_length);
118
  inline void set_quick(char *str,uint32 arg_length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
119 120 121 122 123
  {
    if (!alloced)
    {
      Ptr=(char*) str; str_length=Alloced_length=arg_length;
    }
124
    str_charset=cs;
unknown's avatar
unknown committed
125
  }
126 127 128
  bool set(longlong num, CHARSET_INFO *cs);
  bool set(ulonglong num, CHARSET_INFO *cs);
  bool set(double num,uint decimals, CHARSET_INFO *cs);
unknown's avatar
unknown committed
129
  inline void free()
unknown's avatar
unknown committed
130 131
  {
    if (alloced)
unknown's avatar
unknown committed
132
    {
unknown's avatar
unknown committed
133 134 135 136 137
      alloced=0;
      Alloced_length=0;
      my_free(Ptr,MYF(0));
      Ptr=0;
      str_length=0;				/* Safety */
unknown's avatar
unknown committed
138
    }
unknown's avatar
unknown committed
139
  }
unknown's avatar
unknown committed
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
  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;
      if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
      {
unknown's avatar
unknown committed
155
	Alloced_length = 0;
unknown's avatar
unknown committed
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
	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
179
  bool copy(const char *s,uint32 arg_length, CHARSET_INFO *cs);	// Allocate new string
unknown's avatar
unknown committed
180 181
  bool copy(const char*s,uint32 arg_length, CHARSET_INFO *csfrom,
	    CHARSET_INFO *csto);
unknown's avatar
unknown committed
182 183
  bool append(const String &s);
  bool append(const char *s,uint32 arg_length=0);
184
  bool append(const char *s,uint32 arg_length, CHARSET_INFO *cs);
185
  bool append(IO_CACHE* file, uint32 arg_length);
unknown's avatar
unknown committed
186
  int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
187
  int strstr_case(const String &s,uint32 offset=0);
unknown's avatar
unknown committed
188
  int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
189
  bool replace(uint32 offset,uint32 arg_length,const char *to,uint32 length);
unknown's avatar
unknown committed
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
  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();
207 208
  inline void caseup() { my_caseup(str_charset,Ptr,str_length); }
  inline void casedn() { my_casedn(str_charset,Ptr,str_length); }
209
  friend int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
unknown's avatar
unknown committed
210 211 212
  friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  uint32 numchars();
  int charpos(int i,uint32 offset=0);
unknown's avatar
unknown committed
213 214 215 216 217 218 219

  int reserve(uint32 space_needed)
  {
    return realloc(str_length + space_needed);
  }
  int reserve(uint32 space_needed, uint32 grow_by);

unknown's avatar
unknown committed
220 221 222 223 224
  /*
    The following append operations do NOT check alloced memory
    q_*** methods writes values of parameters itself
    qs_*** methods writes string representation of value
  */
unknown's avatar
unknown committed
225 226 227 228
  void q_append(const char &c)
  {
    Ptr[str_length++] = c;
  }
unknown's avatar
unknown committed
229
  void q_append(const uint32 n)
unknown's avatar
unknown committed
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 255 256 257 258
  {
    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);
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283

  /* Inline (general) functions used by the protocol functions */

  inline char *prep_append(uint32 arg_length, uint32 step_alloc)
  {
    uint32 new_length= arg_length + str_length;
    if (new_length > Alloced_length)
    {
      if (realloc(new_length + step_alloc))
        return 0;
    }
    uint32 old_length= str_length;
    str_length+= arg_length;
    return Ptr+ old_length;			/* Area to use */
  }

  inline bool append(const char *s, uint32 arg_length, uint32 step_alloc)
  {
    uint32 new_length= arg_length + str_length;
    if (new_length > Alloced_length && realloc(new_length + step_alloc))
      return TRUE;
    memcpy(Ptr+str_length, s, arg_length);
    str_length+= arg_length;
    return FALSE;
  }
unknown's avatar
unknown committed
284
};