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
|
/* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB
This file is public domain and comes with NO WARRANTY of any kind */
/* This file is originally from the mysql distribution. Coded by monty */
#ifdef __GNUC__
#pragma interface /* gcc class implementation */
#endif
class String
{
char *Ptr;
uint str_length,Alloced_length;
bool alloced;
public:
String()
{ Ptr=0; str_length=Alloced_length=0; alloced=0; }
String(uint length)
{ alloced=0; Alloced_length=0; (void) real_alloc(length); }
String(const char *str)
{ Ptr=(char*) str; str_length=strlen(str); Alloced_length=0; alloced=0;}
String(const char *str,uint len)
{ Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;}
String(char *str,uint len)
{ Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;}
String(const String &str)
{ Ptr=str.Ptr ; str_length=str.str_length ;
Alloced_length=str.Alloced_length; alloced=0; }
static void *operator new(size_t size) { return (void*) sql_alloc(size); }
static void operator delete(void *ptr,size_t size __attribute__((unused))) /*lint -e715 */
{ sql_element_free(ptr); }
~String() { free(); }
inline uint length() const { return str_length;}
inline uint alloced_length() const { return Alloced_length;}
inline char& operator [] (uint i) const { return Ptr[i]; }
inline void length(uint 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,uint offset,uint length)
{
free();
Ptr=(char*) str.ptr()+offset; str_length=length; alloced=0;
if (str.Alloced_length)
Alloced_length=str.Alloced_length-offset;
else
Alloced_length=0;
}
inline void set(char *str,uint length)
{
free();
Ptr=(char*) str; str_length=length; Alloced_length=length ; alloced=0;
}
inline void set(const char *str,uint length)
{
free();
Ptr=(char*) str; str_length=length; Alloced_length=0 ; alloced=0;
}
inline void set_quick(char *str,uint length)
{
if (!alloced)
{
Ptr=(char*) str; str_length=length; Alloced_length=length;
}
}
void set(longlong num);
/* void set(long num); */
void set(double num,uint decimals=2);
inline void free()
{
if (alloced)
{
alloced=0;
my_free(Ptr,MYF(0));
Ptr=0;
}
}
inline bool alloc(uint length)
{
if (length < Alloced_length)
return 0;
return real_alloc(length);
}
bool real_alloc(uint length); // Empties old string
bool realloc(uint length);
inline void shrink(uint length) // Shrink buffer
{
if (length < Alloced_length)
{
char *new_ptr;
if (!(new_ptr=my_realloc(Ptr,length,MYF(0))))
{
(void) my_free(Ptr,MYF(0));
real_alloc(length);
}
else
{
Ptr=new_ptr;
Alloced_length=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;
}
void copy(); // Alloc string if not alloced
void copy(const String &s); // Allocate new string
void copy(const char *s,uint length); // Allocate new string
void append(const String &s);
void append(const char *s,uint length=0);
int strstr(const String &search,uint offset=0); // Returns offset to substring or -1
int strrstr(const String &search,uint offset=0); // Returns offset to substring or -1
void replace(uint offset,uint 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;
}
void fill(uint max_length,char fill);
void strip_sp();
inline void caseup() { ::caseup(Ptr,str_length); }
inline void casedn() { ::casedn(Ptr,str_length); }
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,uint length);
friend int wild_case_compare(String &match,String &wild);
};
|
