1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* ScummVM - Scumm Interpreter
* Copyright (C) 2002-2004 The ScummVM project
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header$
*/
#ifndef COMMON_STRING_H
#define COMMON_STRING_H
#include "common/scummsys.h"
#include "common/list.h"
#include <assert.h>
#include <string.h>
namespace Common {
/*
TODO
Add a class ConstString which is a light weight base class of String.
It will be immutable, and *not* copy the char pointer it gets when created.
Only constructor: ConstString(const char *ptr)
Then whenever you now use "const String &" in a parameter, use "const ConstString &"
instead (mayhaps make a typedef even). Thus, parameters are passed w/o
causing a free/malloc. Then only for permanent storage, when we assign it to a
real String object, will a malloc be issued (to this end, make String aware of
ConstString ?!?
*/
class ConstString {
friend class String;
protected:
char *_str;
int _len;
public:
ConstString() : _str(0), _len(0) {}
// ConstString(const char *str, int len = -1) : _str((char *)str) { _len = str ? (len >= 0 ? len : strlen(str)) : 0; }
virtual ~ConstString() {}
bool operator ==(const ConstString &x) const;
bool operator ==(const char *x) const;
bool operator !=(const ConstString &x) const;
bool operator !=(const char *x) const;
bool operator <(const ConstString &x) const;
bool operator <=(const ConstString &x) const;
bool operator >(const ConstString &x) const;
bool operator >=(const ConstString &x) const;
char operator [](int idx) const {
assert(_str && idx >= 0 && idx < _len);
return _str[idx];
}
const char *c_str() const { return _str ? _str : ""; }
int size() const { return _len; }
bool isEmpty() const { return (_len == 0); }
};
class String : public ConstString {
protected:
int *_refCount;
int _capacity;
public:
static const String emptyString;
String() : _capacity(0) { _refCount = new int(1); }
String(const char *str, int len = -1);
String(const ConstString &str);
String(const String &str);
virtual ~String();
String &operator =(const char *str);
// TODO - We should use RTTI here - that is, not real C++ RTTI but maybe some magic
// constant in each string object. We want to be able to optimize the case when
// a real 'String' object is passed to a function as a ConstString obj and then
// assigned to a 'String' object.
// An alternative would be to add private clone() and cloneMutable methods that
// would do the right thing.
String &operator =(const String &str);
String &operator +=(const char *str);
String &operator +=(const String &str);
String &operator +=(char c);
char operator [](int idx) const {
assert(_str && idx >= 0 && idx < _len);
return _str[idx];
}
char &operator [](int idx) {
assert(_str && idx >= 0 && idx < _len);
return _str[idx];
}
char lastChar() const;
void deleteLastChar();
void deleteChar(int p);
void clear();
void insertChar(char c, int p);
void toLowercase();
void toUppercase();
protected:
void ensureCapacity(int new_len, bool keep_old);
void decRefCount();
};
// Some useful additional comparision operators for Strings
bool operator == (const char *x, const ConstString &y);
bool operator != (const char *x, const ConstString &y);
class StringList : public List<String> {
public:
void push_back(const char *str) {
ensureCapacity(_size + 1);
_data[_size++] = str;
}
void push_back(const ConstString &str) {
ensureCapacity(_size + 1);
_data[_size++] = str;
}
void push_back(const String &str) {
ensureCapacity(_size + 1);
_data[_size++] = str;
}
};
} // End of namespace Common
#endif
|
