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