← 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: lbieber
  • Date: 2010-10-06 16:34:16 UTC
  • mfrom: (1816.1.3 build)
  • Revision ID: lbieber@orisndriz08-20101006163416-ea0sl59qgpglk21y
Merge Monty - Change the requirement from either libinnodb to libhaildb. Also, tied it to version 2.2
Merge Andrew - fix bug 650935: remove --compress from all clients
Merge Andrew - fix bug 653471: Add -A to drizzle client
Merge Travis - 621861 = To change C structs to C++ classes in Drizzle

Show diffs side-by-side

added added

removed removed

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