← 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: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

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
2
 
 *
3
 
 * PrimeBase Media Stream for MySQL
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
 
 *
19
 
 * Original author: Paul McCullagh (H&G2JCtL)
20
 
 * Continued development: Barry Leslie
21
 
 *
22
 
 * 2007-06-15
23
 
 *
24
 
 * CORE SYSTEM
25
 
 * This class encapsulates a basic string.
26
 
 *
27
 
 */
28
 
 
29
 
#ifndef __CSSTRING_H__
30
 
#define __CSSTRING_H__
31
 
#include <string.h>
32
 
 
33
 
#include "CSDefs.h"
34
 
#include "CSObject.h"
35
 
 
36
 
#ifdef OS_MACINTOSH
37
 
#include <CoreFoundation/CFString.h>
38
 
#endif
39
 
 
40
 
 
41
 
class CSString;
42
 
 
43
 
/*
44
 
 * A unsigned 16-bit unicode character:
45
 
 */
46
 
#define unichar                 uint16_t
47
 
 
48
 
/* CSStringBufferImpl is the string buffer implementation.
49
 
 * Of this implementation we have various types.
50
 
 */
51
 
class CSStringBufferImpl {
52
 
public:
53
 
        CSStringBufferImpl();
54
 
        CSStringBufferImpl(uint32_t grow);
55
 
        ~CSStringBufferImpl();
56
 
 
57
 
        void clear();
58
 
 
59
 
        void append(char ch);
60
 
 
61
 
        void append(const char *str, size_t len);
62
 
 
63
 
        void append(const char *str) {append(str, strlen(str));}
64
 
 
65
 
        void append(int value);
66
 
 
67
 
        void append(uint32_t value);
68
 
 
69
 
        void append(uint64_t value);
70
 
 
71
 
        char *getCString();
72
 
 
73
 
        char *getBuffer(uint32_t pos) { return iBuffer ? iBuffer + pos : NULL; }
74
 
 
75
 
        char *take();
76
 
        
77
 
        void setLength(uint32_t len);
78
 
 
79
 
        void setGrowSize(uint32_t size) { iGrow = size; }
80
 
 
81
 
        uint32_t length() { return myStrLen; }
82
 
 
83
 
        uint32_t ignore(uint32_t pos, char ch);
84
 
 
85
 
        uint32_t find(uint32_t pos, char ch);
86
 
 
87
 
        uint32_t trim(uint32_t pos, char ch);
88
 
 
89
 
        CSString *substr(uint32_t pos, uint32_t len);
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
 
 
99
 
private:
100
 
        char *iBuffer;
101
 
        uint32_t iGrow;
102
 
        uint32_t iSize;
103
 
        uint32_t myStrLen;
104
 
};
105
 
 
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() { }
124
 
};
125
 
 
126
 
class CSSyncStringBuffer : public CSStringBuffer, public CSSync {
127
 
public:
128
 
        CSSyncStringBuffer(uint32_t growSize): CSStringBuffer(growSize), CSSync() { }
129
 
        CSSyncStringBuffer(): CSStringBuffer(), CSSync() { }
130
 
};
131
 
 
132
 
#define CS_CHAR         int
133
 
 
134
 
class CSString : public CSRefObject {
135
 
public:
136
 
        CSString();
137
 
        CSString(const char *cstr);
138
 
        virtual ~CSString();
139
 
 
140
 
        /*
141
 
         * Construct a string from a C-style UTF-8
142
 
         * string.
143
 
         */
144
 
        static CSString *newString(const char *cstr);
145
 
 
146
 
        /* Construct a string from a UTF-8 byte array: */
147
 
        static CSString *newString(const char *bytes, uint32_t len);
148
 
 
149
 
        /* Construct a string from string buffer: */
150
 
        static CSString *newString(CSStringBuffer *sb);
151
 
 
152
 
        /*
153
 
         * Returns a pointer to a UTF-8 string.
154
 
         * The returned string must be
155
 
         * not be freed by the caller.
156
 
         */
157
 
        virtual const char *getCString();
158
 
 
159
 
        /*
160
 
         * Return the character at a certain point:
161
 
         */
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);
165
 
 
166
 
        /*
167
 
         * Returns < 0 if this string is
168
 
         * sorted before val, 0 if equal,
169
 
         * > 0 if sortede after.
170
 
         * The comparison is case-insensitive.
171
 
         */
172
 
        virtual int compare(CSString *val);
173
 
        virtual int compare(const char *val, uint32_t len = ((uint32_t) 0xFFFFFFFF));
174
 
 
175
 
        /*
176
 
         * Case sensitive match.
177
 
         */
178
 
        virtual bool startsWith(uint32_t index, const char *);
179
 
 
180
 
        /* Returns the string length in characters. */
181
 
        virtual uint32_t length() { return myStrLen; }
182
 
        virtual void setLength(uint32_t len);
183
 
 
184
 
        virtual bool equals(const char *str);
185
 
 
186
 
        /*
187
 
         * Return a copy of this string.
188
 
         */
189
 
        virtual CSString *clone(uint32_t pos, uint32_t len);
190
 
 
191
 
        /*
192
 
         * Concatinate 2 strings.
193
 
         */
194
 
        virtual CSString *concat(CSString *str);
195
 
        virtual CSString *concat(const char *str);
196
 
 
197
 
        /* Return an upper case version of the string: */
198
 
        virtual CSString *toUpper();
199
 
 
200
 
        /*
201
 
         * Returns a case-insensitive has
202
 
         * value.
203
 
         */
204
 
        virtual uint32_t hashKey();
205
 
 
206
 
        /*
207
 
         * Locate the count'th occurance of the given
208
 
         * string, moving from left to right or right to
209
 
         * left if count is negative.
210
 
         *
211
 
         * The index of the first character is zero.
212
 
         * If not found, then index returned depends
213
 
         * on the search direction.
214
 
         *
215
 
         * Search from left to right will return
216
 
         * the length of the string, and search
217
 
         * from right to left will return 0.
218
 
         */
219
 
        virtual uint32_t locate(const char *, int32_t count);
220
 
        virtual uint32_t locate(uint32_t pos, const char *);
221
 
        virtual uint32_t locate(uint32_t pos, CS_CHAR ch);
222
 
 
223
 
        virtual uint32_t skip(uint32_t pos, CS_CHAR ch);
224
 
 
225
 
        virtual CSString *substr(uint32_t index, uint32_t size);
226
 
        virtual CSString *substr(uint32_t index);
227
 
 
228
 
        virtual CSString *left(const char *, int32_t count);
229
 
        virtual CSString *left(const char *);
230
 
 
231
 
        virtual CSString *right(const char *, int32_t count);
232
 
        virtual CSString *right(const char *);
233
 
 
234
 
        virtual bool startsWith(const char *);
235
 
        virtual bool endsWith(const char *);
236
 
 
237
 
        /* Return the next position in the string, but do
238
 
         * not go past the length of the string.
239
 
         */
240
 
        virtual uint32_t nextPos(uint32_t pos);
241
 
 
242
 
        virtual CSString *clone(uint32_t len);
243
 
        virtual CSString *clone();
244
 
 
245
 
        virtual CSObject *getKey();
246
 
 
247
 
        virtual int compareKey(CSObject *);
248
 
 
249
 
private:
250
 
        char *myCString;
251
 
        uint32_t myStrLen;
252
 
};
253
 
 
254
 
#endif
255