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