← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Patrick Galbraith
  • Date: 2010-10-03 13:40:30 UTC
  • mto: (1812.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 1813.
  • Revision ID: patg@patg-desktop-20101003134030-j13wf1e79za77jtf
Added license to start_mc.sh.in to clear up ambiguity

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSString.cc
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
 *
14
14
 *
15
15
 * You should have received a copy of the GNU General Public License
16
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
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
18
 *
19
19
 * Original author: Paul McCullagh (H&G2JCtL)
20
20
 * Continued development: Barry Leslie
47
47
 * Core System String Buffers
48
48
 */
49
49
 
50
 
CSStringBufferImpl::CSStringBufferImpl():
 
50
CSStringBuffer_::CSStringBuffer_():
51
51
iBuffer(NULL),
52
52
iGrow(0),
53
53
iSize(0),
56
56
        iGrow = 20;
57
57
}
58
58
 
59
 
CSStringBufferImpl::CSStringBufferImpl(uint32_t grow):
 
59
CSStringBuffer_::CSStringBuffer_(uint32_t grow):
60
60
iBuffer(NULL),
61
61
iGrow(0),
62
62
iSize(0),
65
65
        iGrow = grow;
66
66
}
67
67
 
68
 
CSStringBufferImpl::~CSStringBufferImpl()
 
68
CSStringBuffer_::~CSStringBuffer_()
69
69
{
70
70
        clear();
71
71
}
72
72
 
73
 
void CSStringBufferImpl::clear()
 
73
void CSStringBuffer_::clear()
74
74
{
75
75
        if (iBuffer)
76
76
                cs_free(iBuffer);
79
79
        myStrLen = 0; 
80
80
}
81
81
 
82
 
void CSStringBufferImpl::append(char ch)
 
82
void CSStringBuffer_::append(char ch)
83
83
{
84
84
        if (iSize == myStrLen) {
85
85
                cs_realloc((void **) &iBuffer, iSize + iGrow);
89
89
        myStrLen++;
90
90
}
91
91
 
92
 
void CSStringBufferImpl::append(const char *str, size_t len)
 
92
void CSStringBuffer_::append(const char *str, size_t len)
93
93
{
94
94
        if (myStrLen + len > iSize) {
95
95
                size_t add = len;
103
103
        myStrLen += len;
104
104
}
105
105
 
106
 
void CSStringBufferImpl::append(int value)
107
 
{
108
 
        char buffer[100];
109
 
 
110
 
        snprintf(buffer, 100, "%d", value);
111
 
        append(buffer);
112
 
}
113
 
 
114
 
void CSStringBufferImpl::append(uint32_t value)
115
 
{
116
 
        char buffer[100];
117
 
 
118
 
        snprintf(buffer, 100, "%"PRIu32, value);
119
 
        append(buffer);
120
 
}
121
 
 
122
 
void CSStringBufferImpl::append(uint64_t value)
123
 
{
124
 
        char buffer[100];
125
 
 
126
 
        snprintf(buffer, 100, "%"PRIu64, value);
127
 
        append(buffer);
128
 
}
129
 
 
130
 
char *CSStringBufferImpl::getCString()
 
106
void CSStringBuffer_::append(int value)
 
107
{
 
108
        char buffer[100];
 
109
 
 
110
        snprintf(buffer, 100, "%"PRId32"", value);
 
111
        append(buffer);
 
112
}
 
113
 
 
114
void CSStringBuffer_::append(uint32_t value)
 
115
{
 
116
        char buffer[100];
 
117
 
 
118
        snprintf(buffer, 100, "%"PRIu32"", value);
 
119
        append(buffer);
 
120
}
 
121
 
 
122
char *CSStringBuffer_::getCString()
131
123
{
132
124
        if (iSize == myStrLen) {
133
125
                cs_realloc((void **) &iBuffer, iSize + 1);
137
129
        return iBuffer;
138
130
}
139
131
 
140
 
char *CSStringBufferImpl::take()
 
132
char *CSStringBuffer_::take()
141
133
{
142
134
        char *buf;
143
135
 
152
144
        return buf;
153
145
}
154
146
 
155
 
void CSStringBufferImpl::setLength(uint32_t len)
 
147
void CSStringBuffer_::setLength(uint32_t len)
156
148
{
157
149
        if (len > iSize) {
158
150
                cs_realloc((void **) &iBuffer, len + 1);
161
153
        myStrLen = len;
162
154
}
163
155
 
164
 
uint32_t CSStringBufferImpl::ignore(uint32_t pos, char ch)
 
156
uint32_t CSStringBuffer_::ignore(uint32_t pos, char ch)
165
157
{
166
158
        while (pos < myStrLen && iBuffer[pos] == ch)
167
159
                pos++;
168
160
        return pos;
169
161
}
170
162
 
171
 
uint32_t CSStringBufferImpl::find(uint32_t pos, char ch)
 
163
uint32_t CSStringBuffer_::find(uint32_t pos, char ch)
172
164
{
173
165
        while (pos < myStrLen && iBuffer[pos] != ch)
174
166
                pos++;
175
167
        return pos;
176
168
}
177
169
 
178
 
uint32_t CSStringBufferImpl::trim(uint32_t pos, char ch)
 
170
uint32_t CSStringBuffer_::trim(uint32_t pos, char ch)
179
171
{
180
172
        while (pos > 0 && iBuffer[pos-1] == ch)
181
173
                pos--;
182
174
        return pos;
183
175
}
184
176
 
185
 
CSString *CSStringBufferImpl::substr(uint32_t pos, uint32_t len)
 
177
CSString *CSStringBuffer_::substr(uint32_t pos, uint32_t len)
186
178
{
187
179
        CSString *s = CSString::newString(iBuffer + pos, len);
188
180
 
194
186
 * Generic Strings
195
187
 */
196
188
 
 
189
CSString *CSString::newString(const char *cstr)
 
190
{
 
191
        return CSCString::newString(cstr);
 
192
}
 
193
 
 
194
CSString *CSString::newString(const char *bytes, uint32_t len)
 
195
{
 
196
        return CSCString::newString(bytes, len);
 
197
}
 
198
 
 
199
CSString *CSString::newString(CSStringBuffer *sb)
 
200
{
 
201
        return CSCString::newString(sb);
 
202
}
 
203
 
197
204
CSString *CSString::concat(CSString *cat_str)
198
205
{
199
206
        CSString *new_str = NULL;
260
267
        return (h);
261
268
}
262
269
 
263
 
uint32_t CSString::locate(const char *w_cstr, int32_t count)
 
270
uint32_t CSString::locate(const char *w_cstr, s_int count)
264
271
{
265
 
        int32_t len = length();
266
 
        int32_t i;
 
272
        s_int len = length();
 
273
        s_int i;
267
274
 
268
275
        if (count >= 0) {
269
276
                i = 0;
278
285
        }
279
286
        else {
280
287
                count = -count;
281
 
                i = len - (int32_t) strlen(w_cstr);
 
288
                i = len - (s_int) strlen(w_cstr);
282
289
                while (i >= 0) {
283
290
                        if (startsWith((uint32_t) i, w_cstr)) {
284
291
                                count--;
350
357
        
351
358
}
352
359
 
353
 
CSString *CSString::left(const char *w_cstr, int32_t count)
 
360
CSString *CSString::left(const char *w_cstr, s_int count)
354
361
{
355
362
        uint32_t idx = locate(w_cstr, count);
356
363
 
357
364
        if (idx == (uint32_t)-1)
358
 
                return CSString::newString("");
 
365
                return CSCString::newString("");
359
366
        return substr(0, idx);
360
367
}
361
368
 
364
371
        return left(w_cstr, 1);
365
372
}
366
373
 
367
 
CSString *CSString::right(const char *w_cstr, int32_t count)
 
374
CSString *CSString::right(const char *w_cstr, s_int count)
368
375
{
369
376
        uint32_t idx = locate(w_cstr, count);
370
377
 
371
378
        if (idx == (uint32_t)-1) {
372
 
                return RETAIN(this);
 
379
                this->retain();
 
380
                return this;
373
381
        }
374
382
        
375
383
        if (idx == length())
428
436
 * Standard C String
429
437
 */
430
438
 
431
 
CSString::CSString():
 
439
CSCString::CSCString():
 
440
CSString(),
432
441
myCString(NULL),
433
442
myStrLen(0)
434
443
{
435
444
}
436
445
 
437
 
CSString::CSString(const char *cstr):
438
 
myCString(cs_strdup(cstr)),
439
 
myStrLen(strlen(cstr))
440
 
{
441
 
}
442
 
 
443
 
CSString::~CSString()
 
446
CSCString::~CSCString()
444
447
{
445
448
        if (myCString)
446
449
                cs_free(myCString);
447
450
}
448
451
 
449
 
const char *CSString::getCString()
 
452
const char *CSCString::getCString()
450
453
{
451
454
        return myCString;
452
455
}
453
456
 
454
 
CS_CHAR CSString::charAt(uint32_t pos)
 
457
CS_CHAR CSCString::charAt(uint32_t pos)
455
458
{
456
459
        if (pos < myStrLen)
457
460
                return (CS_CHAR) (unsigned char) myCString[pos];
458
461
        return (CS_CHAR) 0;
459
462
}
460
463
 
461
 
CS_CHAR CSString::upperCharAt(uint32_t pos)
 
464
CS_CHAR CSCString::upperCharAt(uint32_t pos)
462
465
{
463
466
        if (pos < myStrLen)
464
467
                return (CS_CHAR) (unsigned char) toupper(myCString[pos]);
465
468
        return (CS_CHAR) 0;
466
469
}
467
470
 
468
 
void CSString::setCharAt(uint32_t pos, CS_CHAR ch)
 
471
void CSCString::setCharAt(uint32_t pos, CS_CHAR ch)
469
472
{
470
473
        if (pos < myStrLen)
471
474
                myCString[pos] = (unsigned char) ch;
472
475
}
473
476
 
474
 
int CSString::compare(const char *val, uint32_t len)
 
477
int CSCString::compare(const char *val, uint32_t len)
475
478
{
476
479
        const char *pa = myCString, *pb = val;
477
480
        int r = 0;
494
497
        return_(r);
495
498
}
496
499
 
497
 
int CSString::compare(CSString *val)
 
500
int CSCString::compare(CSString *val)
498
501
{
499
502
        return compare(val->getCString(), (uint32_t)-1);
500
503
}
501
504
 
502
 
bool CSString::startsWith(uint32_t index, const char *w_str)
 
505
bool CSCString::startsWith(uint32_t index, const char *w_str)
503
506
{
504
507
        uint32_t len = strlen(w_str);
505
508
        char *str;
516
519
        return (*w_str == 0);
517
520
}
518
521
 
519
 
void CSString::setLength(uint32_t len)
 
522
void CSCString::setLength(uint32_t len)
520
523
{
521
524
        cs_realloc((void **) &myCString, len+1);
522
525
        myCString[len] = 0;
523
526
        myStrLen = len;
524
527
}
525
528
 
526
 
CSString *CSString::clone(uint32_t pos, uint32_t len)
 
529
CSString *CSCString::clone(uint32_t pos, uint32_t len)
527
530
{
528
 
        CSString *str = NULL;
 
531
        CSCString *str = NULL;
529
532
        
530
533
        enter_();
531
 
        new_(str, CSString());
 
534
        new_(str, CSCString());
532
535
        push_(str);
533
536
        
534
537
        str->myCString = (char *) cs_malloc(len + 1);
551
554
        return_(str);
552
555
}
553
556
 
554
 
CSObject *CSString::getKey()
 
557
CSObject *CSCString::getKey()
555
558
{
556
559
        return (CSObject *) this;
557
560
}
558
561
 
559
 
int CSString::compareKey(CSObject *key)
 
562
int CSCString::compareKey(CSObject *key)
560
563
{
561
564
        return compare((CSString *) key);
562
565
}
563
566
 
564
 
CSString *CSString::newString(const char *cstr)
 
567
CSCString *CSCString::newString(const char *cstr)
565
568
{
566
 
        CSString *str;
 
569
        CSCString *str;
567
570
        
568
571
        enter_();
569
 
        new_(str, CSString());
 
572
        new_(str, CSCString());
570
573
        push_(str);
571
574
        str->myCString = cs_strdup(cstr);
572
575
        str->myStrLen = strlen(cstr);
574
577
        return_(str);
575
578
}
576
579
 
577
 
CSString *CSString::newString(const char *bytes, uint32_t len)
 
580
CSCString *CSCString::newString(const char *bytes, uint32_t len)
578
581
{
579
 
        CSString *str;
 
582
        CSCString *str;
580
583
        
581
584
        enter_();
582
 
        new_(str, CSString());
 
585
        new_(str, CSCString());
583
586
        push_(str);
584
587
        str->myStrLen = len;
585
588
        str->myCString = (char *) cs_malloc(len+1);
589
592
        return_(str);
590
593
}
591
594
 
592
 
CSString *CSString::newString(CSStringBuffer *sb)
 
595
CSCString *CSCString::newString(CSStringBuffer *sb)
593
596
{
594
 
        CSString *str;
 
597
        CSCString *str;
595
598
        
596
599
        enter_();
597
600
        push_(sb);
598
 
        new_(str, CSString());
 
601
        new_(str, CSCString());
599
602
        push_(str);
 
603
        str->myCString = sb->take();
600
604
        str->myStrLen = sb->length();
601
 
        str->myCString = sb->take();
602
605
        pop_(str);
603
 
        pop_(sb); // pop this do not release it because CSStringBuffer is NOT a CSRefObject. 
 
606
        release_(sb);
604
607
        return_(str);
605
608
}
606
609