← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSString.h

  • Committer: Lee Bieber
  • Date: 2010-10-22 16:47:38 UTC
  • mfrom: (1841.1.7 drizzle_pbms)
  • Revision ID: kalebral@gmail.com-20101022164738-vv8w22b8towpb307
Merge Barry - fix bug 657830: PBMS build failure in GCC 4.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSString.h
45
45
 */
46
46
#define unichar                 uint16_t
47
47
 
48
 
// CSStringBuffer_ is just a base class to define
49
 
// referenced and non referenced versions on.
50
 
class CSStringBuffer_ {
 
48
/* CSStringBufferImpl is the string buffer implementation.
 
49
 * Of this implementation we have various types.
 
50
 */
 
51
class CSStringBufferImpl {
51
52
public:
52
 
        CSStringBuffer_();
53
 
        CSStringBuffer_(uint32_t grow);
54
 
        ~CSStringBuffer_();
 
53
        CSStringBufferImpl();
 
54
        CSStringBufferImpl(uint32_t grow);
 
55
        ~CSStringBufferImpl();
55
56
 
56
57
        void clear();
57
58
 
65
66
 
66
67
        void append(uint32_t value);
67
68
 
 
69
        void append(uint64_t value);
 
70
 
68
71
        char *getCString();
69
72
 
70
73
        char *getBuffer(uint32_t pos) { return iBuffer ? iBuffer + pos : NULL; }
85
88
 
86
89
        CSString *substr(uint32_t pos, uint32_t len);
87
90
 
 
91
        void take(CSStringBufferImpl *buf) {
 
92
                clear();
 
93
                iGrow = buf->iGrow;
 
94
                iSize = buf->iSize;
 
95
                myStrLen = buf->myStrLen;
 
96
                iBuffer = buf->take();
 
97
        }
 
98
 
88
99
private:
89
100
        char *iBuffer;
90
101
        uint32_t iGrow;
92
103
        uint32_t myStrLen;
93
104
};
94
105
 
95
 
class CSStringBuffer : public CSStringBuffer_, public CSObject {
96
 
public:
97
 
        CSStringBuffer(): CSStringBuffer_(){ }
98
 
        CSStringBuffer(uint32_t grow): CSStringBuffer_(grow){ }
99
 
};
100
 
 
101
 
class CSRefStringBuffer : public CSStringBuffer_, public CSRefObject {
102
 
public:
103
 
        CSRefStringBuffer(): CSStringBuffer_(){ }
104
 
        CSRefStringBuffer(uint32_t grow): CSStringBuffer_(grow){ }
 
106
class CSStringBuffer : public CSStringBufferImpl, public CSObject {
 
107
public:
 
108
        CSStringBuffer(): CSStringBufferImpl(), CSObject() { }
 
109
        CSStringBuffer(uint32_t grow): CSStringBufferImpl(grow), CSObject() { }
 
110
};
 
111
 
 
112
class CSStaticStringBuffer : public CSStringBufferImpl, public CSStaticObject {
 
113
        virtual void finalize() { clear(); }
 
114
 
 
115
public:
 
116
        CSStaticStringBuffer(): CSStringBufferImpl(), CSStaticObject() { }
 
117
        CSStaticStringBuffer(uint32_t grow): CSStringBufferImpl(grow), CSStaticObject() { }
 
118
};
 
119
 
 
120
class CSRefStringBuffer : public CSStringBufferImpl, public CSRefObject {
 
121
public:
 
122
        CSRefStringBuffer(): CSStringBufferImpl(), CSRefObject() { }
 
123
        CSRefStringBuffer(uint32_t grow): CSStringBufferImpl(grow), CSRefObject() { }
105
124
};
106
125
 
107
126
class CSSyncStringBuffer : public CSStringBuffer, public CSSync {
114
133
 
115
134
class CSString : public CSRefObject {
116
135
public:
117
 
        CSString() { }
118
 
        virtual ~CSString() { }
 
136
        CSString();
 
137
        CSString(const char *cstr);
 
138
        virtual ~CSString();
119
139
 
120
140
        /*
121
141
         * Construct a string from a C-style UTF-8
134
154
         * The returned string must be
135
155
         * not be freed by the caller.
136
156
         */
137
 
        virtual const char *getCString() = 0;
 
157
        virtual const char *getCString();
138
158
 
139
159
        /*
140
160
         * Return the character at a certain point:
141
161
         */
142
 
        virtual CS_CHAR charAt(uint32_t pos) = 0;
143
 
        virtual CS_CHAR upperCharAt(uint32_t pos) = 0;
144
 
        virtual void setCharAt(uint32_t pos, CS_CHAR ch) = 0;
 
162
        virtual CS_CHAR charAt(uint32_t pos);
 
163
        virtual CS_CHAR upperCharAt(uint32_t pos);
 
164
        virtual void setCharAt(uint32_t pos, CS_CHAR ch);
145
165
 
146
166
        /*
147
167
         * Returns < 0 if this string is
149
169
         * > 0 if sortede after.
150
170
         * The comparison is case-insensitive.
151
171
         */
152
 
        virtual int compare(CSString *val) = 0;
153
 
        virtual int compare(const char *val, uint32_t len = ((uint32_t) 0xFFFFFFFF)) = 0;
 
172
        virtual int compare(CSString *val);
 
173
        virtual int compare(const char *val, uint32_t len = ((uint32_t) 0xFFFFFFFF));
154
174
 
155
175
        /*
156
176
         * Case sensitive match.
157
177
         */
158
 
        virtual bool startsWith(uint32_t index, const char *) = 0;
 
178
        virtual bool startsWith(uint32_t index, const char *);
159
179
 
160
180
        /* Returns the string length in characters. */
161
 
        virtual uint32_t length() = 0;
162
 
        virtual void setLength(uint32_t len) = 0;
 
181
        virtual uint32_t length() { return myStrLen; }
 
182
        virtual void setLength(uint32_t len);
163
183
 
164
184
        virtual bool equals(const char *str);
165
185
 
166
186
        /*
167
187
         * Return a copy of this string.
168
188
         */
169
 
        virtual CSString *clone(uint32_t pos, uint32_t len) = 0;
 
189
        virtual CSString *clone(uint32_t pos, uint32_t len);
170
190
 
171
191
        /*
172
192
         * Concatinate 2 strings.
196
216
         * the length of the string, and search
197
217
         * from right to left will return 0.
198
218
         */
199
 
        virtual uint32_t locate(const char *, s_int count);
 
219
        virtual uint32_t locate(const char *, int32_t count);
200
220
        virtual uint32_t locate(uint32_t pos, const char *);
201
221
        virtual uint32_t locate(uint32_t pos, CS_CHAR ch);
202
222
 
205
225
        virtual CSString *substr(uint32_t index, uint32_t size);
206
226
        virtual CSString *substr(uint32_t index);
207
227
 
208
 
        virtual CSString *left(const char *, s_int count);
 
228
        virtual CSString *left(const char *, int32_t count);
209
229
        virtual CSString *left(const char *);
210
230
 
211
 
        virtual CSString *right(const char *, s_int count);
 
231
        virtual CSString *right(const char *, int32_t count);
212
232
        virtual CSString *right(const char *);
213
233
 
214
234
        virtual bool startsWith(const char *);
221
241
 
222
242
        virtual CSString *clone(uint32_t len);
223
243
        virtual CSString *clone();
224
 
};
225
 
 
226
 
class CSCString : public CSString {
227
 
public:
228
 
        char *myCString;
229
 
        uint32_t myStrLen;
230
 
 
231
 
        CSCString();
232
 
        ~CSCString();
233
 
 
234
 
 
235
 
        virtual const char *getCString();
236
 
 
237
 
        virtual CS_CHAR charAt(uint32_t pos);
238
 
 
239
 
        virtual CS_CHAR upperCharAt(uint32_t pos);
240
 
 
241
 
        virtual void setCharAt(uint32_t pos, CS_CHAR ch);
242
 
 
243
 
        virtual int compare(CSString *val);
244
 
        virtual int compare(const char *val, uint32_t len = ((uint32_t) 0xFFFFFFFF));
245
 
 
246
 
        virtual bool startsWith(uint32_t index, const char *);
247
 
        virtual bool startsWith(const char *str) { return CSString::startsWith(str);}
248
 
 
249
 
        virtual uint32_t length() { return myStrLen; }
250
 
 
251
 
        virtual void setLength(uint32_t len);
252
 
 
253
 
        virtual CSString *clone(uint32_t pos, uint32_t len);
254
 
        virtual CSString *clone(uint32_t len){ return CSString::clone(len);}
255
 
        virtual CSString *clone(){ return CSString::clone();}
256
244
 
257
245
        virtual CSObject *getKey();
258
246
 
259
247
        virtual int compareKey(CSObject *);
260
248
 
261
 
        static CSCString *newString(const char *cstr);
262
 
 
263
 
        static CSCString *newString(const char *bytes, uint32_t len);
264
 
 
265
 
        static CSCString *newString(CSStringBuffer *sb);
 
249
private:
 
250
        char *myCString;
 
251
        uint32_t myStrLen;
266
252
};
267
253
 
268
254
#endif