1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
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
255
256
257
258
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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
*
* Copyright (C) 2008 Sun Microsystems, Inc.
*
* 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; version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
/* This file is originally from the mysql distribution. Coded by monty */
#include <drizzled/common.h>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <string>
#include <drizzled/visibility.h>
#ifndef NOT_FIXED_DEC
#define NOT_FIXED_DEC (uint8_t)31
#endif
namespace drizzled
{
class String;
struct charset_info_st;
extern DRIZZLED_API String my_empty_string;
extern const String my_null_string;
namespace memory { class Root; }
DRIZZLED_API std::string String_to_std_string(String const& s);
DRIZZLED_API String* set_String_from_std_string(String* s, std::string const& cs);
int sortcmp(const String *a,const String *b, const charset_info_st * const cs);
int stringcmp(const String *a,const String *b);
String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
size_t well_formed_copy_nchars(const charset_info_st * const to_cs,
char *to, size_t to_length,
const charset_info_st * const from_cs,
const char *from, size_t from_length,
size_t nchars,
const char **well_formed_error_pos,
const char **cannot_convert_error_pos,
const char **from_end_pos);
class DRIZZLED_API String
{
char *Ptr;
size_t str_length,Alloced_length;
bool alloced;
const charset_info_st *str_charset;
public:
String();
String(size_t length_arg);
String(const char *str, const charset_info_st * const cs);
String(const char *str, size_t len, const charset_info_st * const cs);
String(char *str, size_t len, const charset_info_st * const cs);
String(const String &str);
static void *operator new(size_t size, memory::Root *mem_root);
static void operator delete(void *, size_t)
{ }
static void operator delete(void *, memory::Root *)
{ }
~String();
inline void set_charset(const charset_info_st * const charset_arg)
{ str_charset= charset_arg; }
inline const charset_info_st *charset() const { return str_charset; }
inline size_t length() const { return str_length;}
inline size_t alloced_length() const { return Alloced_length;}
inline char& operator [] (size_t i) const { return Ptr[i]; }
inline void length(size_t len) { str_length=len ; }
inline bool is_empty() { return (str_length == 0); }
inline void mark_as_const() { Alloced_length= 0;}
inline char *ptr() { return Ptr; }
inline const char *ptr() const { return Ptr; }
inline char *c_ptr()
{
if (str_length == Alloced_length)
(void) realloc(str_length);
else
Ptr[str_length]= 0;
return Ptr;
}
inline char *c_ptr_quick()
{
if (Ptr && str_length < Alloced_length)
Ptr[str_length]=0;
return Ptr;
}
inline char *c_ptr_safe()
{
if (Ptr && str_length < Alloced_length)
Ptr[str_length]=0;
else
(void) realloc(str_length);
return Ptr;
}
inline char *c_str()
{
if (Ptr && str_length < Alloced_length)
Ptr[str_length]=0;
else
(void) realloc(str_length);
return Ptr;
}
void append_identifier(const char *name, size_t length);
void set(String &str,size_t offset,size_t arg_length)
{
assert(&str != this);
free();
Ptr= str.ptr()+offset; str_length=arg_length; alloced=0;
if (str.Alloced_length)
Alloced_length=str.Alloced_length-offset;
else
Alloced_length=0;
str_charset=str.str_charset;
}
inline void set(char *str,size_t arg_length, const charset_info_st * const cs)
{
free();
Ptr= str; str_length=Alloced_length=arg_length ; alloced=0;
str_charset=cs;
}
inline void set(const char *str,size_t arg_length, const charset_info_st * const cs)
{
free();
Ptr= const_cast<char*>(str);
str_length=arg_length; Alloced_length=0 ; alloced=0;
str_charset=cs;
}
bool set_ascii(const char *str, size_t arg_length);
inline void set_quick(char *str,size_t arg_length, const charset_info_st * const cs)
{
if (!alloced)
{
Ptr= str; str_length= Alloced_length= arg_length;
}
str_charset= cs;
}
bool set_int(int64_t num, bool unsigned_flag, const charset_info_st * const cs);
bool set(int64_t num, const charset_info_st * const cs)
{ return set_int(num, false, cs); }
bool set(uint64_t num, const charset_info_st * const cs)
{ return set_int(static_cast<int64_t>(num), true, cs); }
bool set_real(double num,size_t decimals, const charset_info_st * const cs);
/*
PMG 2004.11.12
This is a method that works the same as perl's "chop". It simply
drops the last character of a string. This is useful in the case
of the federated storage handler where I'm building a unknown
number, list of values and fields to be used in a sql insert
statement to be run on the remote server, and have a comma after each.
When the list is complete, I "chop" off the trailing comma
ex.
String stringobj;
stringobj.append("VALUES ('foo', 'fi', 'fo',");
stringobj.chop();
stringobj.append(")");
In this case, the value of string was:
VALUES ('foo', 'fi', 'fo',
VALUES ('foo', 'fi', 'fo'
VALUES ('foo', 'fi', 'fo')
*/
inline void chop()
{
Ptr[str_length--]= '\0';
}
inline void free()
{
if (alloced)
{
alloced=0;
Alloced_length=0;
::free(Ptr);
Ptr=0;
str_length=0; /* Safety */
}
}
inline bool alloc(size_t arg_length)
{
if (arg_length < Alloced_length)
return 0;
return real_alloc(arg_length);
}
bool real_alloc(size_t arg_length); // Empties old string
bool realloc(size_t arg_length);
inline void shrink(size_t arg_length) // Shrink buffer
{
if (arg_length < Alloced_length)
{
char *new_ptr;
if (!(new_ptr= reinterpret_cast<char*>(::realloc(Ptr,arg_length))))
{
Alloced_length = 0;
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)
{
/*
It is forbidden to do assignments like
some_string = substring_of_that_string
*/
assert(!s.uses_buffer_owned_by(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 std::string&, const charset_info_st * const cs); // Allocate new string
bool copy(const char *s,size_t arg_length, const charset_info_st * const cs); // Allocate new string
static bool needs_conversion(size_t arg_length,
const charset_info_st * const cs_from, const charset_info_st * const cs_to,
size_t *offset);
bool set_or_copy_aligned(const char *s, size_t arg_length, const charset_info_st * const cs);
bool copy(const char*s,size_t arg_length, const charset_info_st * const csfrom,
const charset_info_st * const csto, size_t *errors);
bool append(const String &s);
bool append(const char *s);
bool append(const char *s,size_t arg_length);
bool append(const char *s,size_t arg_length, const charset_info_st * const cs);
bool append_with_prefill(const char *s, size_t arg_length,
size_t full_length, char fill_char);
int strstr(const String &search,size_t offset=0); // Returns offset to substring or -1
int strrstr(const String &search,size_t offset=0); // Returns offset to substring or -1
bool replace(size_t offset,size_t arg_length,const char *to,size_t length);
bool replace(size_t offset,size_t 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;
}
friend int sortcmp(const String *a,const String *b, const charset_info_st * const cs);
friend int stringcmp(const String *a,const String *b);
friend String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
size_t numchars();
int charpos(int i,size_t offset=0);
int reserve(size_t space_needed)
{
return realloc(str_length + space_needed);
}
int reserve(size_t space_needed, size_t grow_by);
/*
The following 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);
void q_append(const size_t n);
void q_append(double d);
void q_append(double *d);
void q_append(const char *data, size_t data_len);
void write_at_position(int position, size_t value);
/* Inline (general) functions used by the protocol functions */
inline char *prep_append(size_t arg_length, size_t step_alloc)
{
size_t new_length= arg_length + str_length;
if (new_length > Alloced_length)
{
if (realloc(new_length + step_alloc))
return 0;
}
size_t old_length= str_length;
str_length+= arg_length;
return Ptr+ old_length; /* Area to use */
}
inline bool append(const char *s, size_t arg_length, size_t step_alloc)
{
size_t 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;
}
void print(String *print);
/* Swap two string objects. Efficient way to exchange data without memcpy. */
void swap(String &s);
inline bool uses_buffer_owned_by(const String *s) const
{
return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length);
}
};
bool check_if_only_end_space(const charset_info_st * const cs, char *str,
char *end);
std::ostream& operator<<(std::ostream& output, const String &str);
} /* namespace drizzled */
bool operator==(const drizzled::String &s1, const drizzled::String &s2);
bool operator!=(const drizzled::String &s1, const drizzled::String &s2);
|