Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | #!/usr/bin/env python |
2 | ## vim:ts=4:et:nowrap | |
3 | """A user-defined wrapper around string objects | |
4 | ||
5 | Note: string objects have grown methods in Python 1.6 | |
6 | This module requires Python 1.6 or later. | |
7 | """ | |
8 | from types import StringTypes | |
9 | import sys | |
10 | ||
11 | __all__ = ["UserString","MutableString"] | |
12 | ||
13 | class UserString: | |
14 | def __init__(self, seq): | |
15 | if isinstance(seq, StringTypes): | |
16 | self.data = seq | |
17 | elif isinstance(seq, UserString): | |
18 | self.data = seq.data[:] | |
19 | else: | |
20 | self.data = str(seq) | |
21 | def __str__(self): return str(self.data) | |
22 | def __repr__(self): return repr(self.data) | |
23 | def __int__(self): return int(self.data) | |
24 | def __long__(self): return long(self.data) | |
25 | def __float__(self): return float(self.data) | |
26 | def __complex__(self): return complex(self.data) | |
27 | def __hash__(self): return hash(self.data) | |
28 | ||
29 | def __cmp__(self, string): | |
30 | if isinstance(string, UserString): | |
31 | return cmp(self.data, string.data) | |
32 | else: | |
33 | return cmp(self.data, string) | |
34 | def __contains__(self, char): | |
35 | return char in self.data | |
36 | ||
37 | def __len__(self): return len(self.data) | |
38 | def __getitem__(self, index): return self.__class__(self.data[index]) | |
39 | def __getslice__(self, start, end): | |
40 | start = max(start, 0); end = max(end, 0) | |
41 | return self.__class__(self.data[start:end]) | |
42 | ||
43 | def __add__(self, other): | |
44 | if isinstance(other, UserString): | |
45 | return self.__class__(self.data + other.data) | |
46 | elif isinstance(other, StringTypes): | |
47 | return self.__class__(self.data + other) | |
48 | else: | |
49 | return self.__class__(self.data + str(other)) | |
50 | def __radd__(self, other): | |
51 | if isinstance(other, StringTypes): | |
52 | return self.__class__(other + self.data) | |
53 | else: | |
54 | return self.__class__(str(other) + self.data) | |
55 | def __mul__(self, n): | |
56 | return self.__class__(self.data*n) | |
57 | __rmul__ = __mul__ | |
58 | def __mod__(self, args): | |
59 | return self.__class__(self.data % args) | |
60 | ||
61 | # the following methods are defined in alphabetical order: | |
62 | def capitalize(self): return self.__class__(self.data.capitalize()) | |
63 | def center(self, width, *args): | |
64 | return self.__class__(self.data.center(width, *args)) | |
65 | def count(self, sub, start=0, end=sys.maxint): | |
66 | return self.data.count(sub, start, end) | |
67 | def decode(self, encoding=None, errors=None): # XXX improve this? | |
68 | if encoding: | |
69 | if errors: | |
70 | return self.__class__(self.data.decode(encoding, errors)) | |
71 | else: | |
72 | return self.__class__(self.data.decode(encoding)) | |
73 | else: | |
74 | return self.__class__(self.data.decode()) | |
75 | def encode(self, encoding=None, errors=None): # XXX improve this? | |
76 | if encoding: | |
77 | if errors: | |
78 | return self.__class__(self.data.encode(encoding, errors)) | |
79 | else: | |
80 | return self.__class__(self.data.encode(encoding)) | |
81 | else: | |
82 | return self.__class__(self.data.encode()) | |
83 | def endswith(self, suffix, start=0, end=sys.maxint): | |
84 | return self.data.endswith(suffix, start, end) | |
85 | def expandtabs(self, tabsize=8): | |
86 | return self.__class__(self.data.expandtabs(tabsize)) | |
87 | def find(self, sub, start=0, end=sys.maxint): | |
88 | return self.data.find(sub, start, end) | |
89 | def index(self, sub, start=0, end=sys.maxint): | |
90 | return self.data.index(sub, start, end) | |
91 | def isalpha(self): return self.data.isalpha() | |
92 | def isalnum(self): return self.data.isalnum() | |
93 | def isdecimal(self): return self.data.isdecimal() | |
94 | def isdigit(self): return self.data.isdigit() | |
95 | def islower(self): return self.data.islower() | |
96 | def isnumeric(self): return self.data.isnumeric() | |
97 | def isspace(self): return self.data.isspace() | |
98 | def istitle(self): return self.data.istitle() | |
99 | def isupper(self): return self.data.isupper() | |
100 | def join(self, seq): return self.data.join(seq) | |
101 | def ljust(self, width, *args): | |
102 | return self.__class__(self.data.ljust(width, *args)) | |
103 | def lower(self): return self.__class__(self.data.lower()) | |
104 | def lstrip(self, chars=None): return self.__class__(self.data.lstrip(chars)) | |
105 | def replace(self, old, new, maxsplit=-1): | |
106 | return self.__class__(self.data.replace(old, new, maxsplit)) | |
107 | def rfind(self, sub, start=0, end=sys.maxint): | |
108 | return self.data.rfind(sub, start, end) | |
109 | def rindex(self, sub, start=0, end=sys.maxint): | |
110 | return self.data.rindex(sub, start, end) | |
111 | def rjust(self, width, *args): | |
112 | return self.__class__(self.data.rjust(width, *args)) | |
113 | def rstrip(self, chars=None): return self.__class__(self.data.rstrip(chars)) | |
114 | def split(self, sep=None, maxsplit=-1): | |
115 | return self.data.split(sep, maxsplit) | |
116 | def rsplit(self, sep=None, maxsplit=-1): | |
117 | return self.data.rsplit(sep, maxsplit) | |
118 | def splitlines(self, keepends=0): return self.data.splitlines(keepends) | |
119 | def startswith(self, prefix, start=0, end=sys.maxint): | |
120 | return self.data.startswith(prefix, start, end) | |
121 | def strip(self, chars=None): return self.__class__(self.data.strip(chars)) | |
122 | def swapcase(self): return self.__class__(self.data.swapcase()) | |
123 | def title(self): return self.__class__(self.data.title()) | |
124 | def translate(self, *args): | |
125 | return self.__class__(self.data.translate(*args)) | |
126 | def upper(self): return self.__class__(self.data.upper()) | |
127 | def zfill(self, width): return self.__class__(self.data.zfill(width)) | |
128 | ||
129 | class MutableString(UserString): | |
130 | """mutable string objects | |
131 | ||
132 | Python strings are immutable objects. This has the advantage, that | |
133 | strings may be used as dictionary keys. If this property isn't needed | |
134 | and you insist on changing string values in place instead, you may cheat | |
135 | and use MutableString. | |
136 | ||
137 | But the purpose of this class is an educational one: to prevent | |
138 | people from inventing their own mutable string class derived | |
139 | from UserString and than forget thereby to remove (override) the | |
140 | __hash__ method inherited from UserString. This would lead to | |
141 | errors that would be very hard to track down. | |
142 | ||
143 | A faster and better solution is to rewrite your program using lists.""" | |
144 | def __init__(self, string=""): | |
145 | self.data = string | |
146 | def __hash__(self): | |
147 | raise TypeError, "unhashable type (it is mutable)" | |
148 | def __setitem__(self, index, sub): | |
149 | if index < 0 or index >= len(self.data): raise IndexError | |
150 | self.data = self.data[:index] + sub + self.data[index+1:] | |
151 | def __delitem__(self, index): | |
152 | if index < 0 or index >= len(self.data): raise IndexError | |
153 | self.data = self.data[:index] + self.data[index+1:] | |
154 | def __setslice__(self, start, end, sub): | |
155 | start = max(start, 0); end = max(end, 0) | |
156 | if isinstance(sub, UserString): | |
157 | self.data = self.data[:start]+sub.data+self.data[end:] | |
158 | elif isinstance(sub, StringTypes): | |
159 | self.data = self.data[:start]+sub+self.data[end:] | |
160 | else: | |
161 | self.data = self.data[:start]+str(sub)+self.data[end:] | |
162 | def __delslice__(self, start, end): | |
163 | start = max(start, 0); end = max(end, 0) | |
164 | self.data = self.data[:start] + self.data[end:] | |
165 | def immutable(self): | |
166 | return UserString(self.data) | |
167 | def __iadd__(self, other): | |
168 | if isinstance(other, UserString): | |
169 | self.data += other.data | |
170 | elif isinstance(other, StringTypes): | |
171 | self.data += other | |
172 | else: | |
173 | self.data += str(other) | |
174 | return self | |
175 | def __imul__(self, n): | |
176 | self.data *= n | |
177 | return self | |
178 | ||
179 | if __name__ == "__main__": | |
180 | # execute the regression test to stdout, if called as a script: | |
181 | import os | |
182 | called_in_dir, called_as = os.path.split(sys.argv[0]) | |
183 | called_as, py = os.path.splitext(called_as) | |
184 | if '-q' in sys.argv: | |
185 | from test import test_support | |
186 | test_support.verbose = 0 | |
187 | __import__('test.test_' + called_as.lower()) |