1: #!/usr/bin/env rexx
2: /**
3: * A stringTable subclass that will support indexes of one word
4: * strings in any case (lower- upper- or mixed-case) and treat
5: * them as being the same when processing.
6: * ----------------------------------------------------------------
7: * Originally by Ruurd J. Idenburg
8: *
9: * No copyright, no licence, no guarantees or warrantees, be it
10: * explicit, implicit or whatever. Usage is totally and completely
11: * at the users own risk, the author shall not be liable for any
12: * damages whatsoever, for any reason whatsoever.
13: *
14: * Please keep this comment block intact when modifying this code
15: * and add a note with date and a description.
16: * ----------------------------------------------------------------
17: * 2023/02/08 - Initial version requires ooRexx version 5.0.0 or
18: * later
19: * 2023/04/02 - Added catering for multi-word indexes by removing
20: * the spaces between words when processing them (rji)
21: * 2023/05/04 - Added a (perhaps) more common example (rji)
22: * 2023/05/05 - Removed unneccesary exit statements in method
23: * definitions (rji)
24: *
25: */----------------------------------------------------------------
26:
27: -- A simple sample
28: cst = .caselessStringTable~new
29: say "HELLO =>" cst~hello
30: cst["Blonde On Blonde"] = "An album by Bob Dylan"
31: cst~blonde = "My Hair"
32: --say cst~allIndexes
33: say "blond On Blonde => "cst["blonde On blonde"]
34: say "Blonde =>" cst["Blonde"]
35: say "Real indexes =>" cst~makeArray~toString(,", ")
36: say "Index BLONDE ONBLONDE =>" cst~hasIndex("BLONDE ONBLONDE")
37: say "Removing bLoNdE =>" cst~remove("bLoNdE")
38: say "-"~copies(40)
39: -- A more common (perhaps) sample
40: memberList = .routines~createMemberList~call
41: say "Actual indexes:" memberList[0]~allIndexes~sort~toString(,", ")
42: say "Used indexes..: ~first, ~last, ~middle"
43: say "-"~copies(40)
44: do m over memberList
45: if m~middle==.nil
46: then say m~last"," m~first"," "middle name to be done"
47: else say m~last"," m~first"," m~middle
48: end
49: say "-"~copies(40)
50:
51: /**
52: * Do not execute above code when invoked via a "::requires" directive
53: */
54: ::options noprolog
55:
56: /**
57: * All indexes are maintained in the .caselessStringTable superclass
58: * (i.e the .stringTable class). All methods with an index as argument
59: * are first checked for a caseless match before being forwarded to
60: * the superclass .stringTable methods.
61: */
62: ::class "caselessStringTable" public subclass "stringTable"
63:
64: /**
65: * Just let the superclass initiate the instance
66: */
67: ::method "init"
68: self~init:super
69: exit
70:
71: /**
72: * Will check if there is already an index exactly the same in mixed-
73: * or lower- or upper-case and return the matched index, otherwise
74: * will return the index given as the parameter.
75: */
76: ::method "caselessIndex" private
77: use strict arg key
78: /**
79: * Make sure the index will be one word only
80: */
81: key = key~space(0)
82: tmpString = self~makeArray~toString(," ")
83: wp = tmpString~caselessWordPos(key)
84: if wp=0
85: then tableIndex = key
86: else tableIndex = tmpString~word(wp)
87: return tableIndex
88:
89: /**
90: * This is the same as method "at", so let the"at' method handle it
91: */
92: ::method "[]"
93: forward to (self) message ("at")
94: exit
95:
96: /**
97: * This the same method as "put", so let the "put' method handle it
98: */
99: ::method "[]="
100: forward to (self) message ("put")
101: exit
102:
103: /**
104: * Same as the super class, but with the caseless match
105: * for it's indexes.
106: */
107: ::method "at"
108: use strict arg key
109: index = self~caselessIndex(key)
110: return self~at:super(index)
111:
112: /**
113: * Same as the super class, but with the caseless match
114: * for it's indexes.
115: */
116: ::method "hasIndex"
117: use strict arg key
118: index = self~caselessIndex(key)
119: return self~hasIndex:super(index)
120:
121: /**
122: * Same as the super class, but with the caseless for it's
123: * indexes.If a caseless match exists the item value will be
124: * updated. If no match is found the index will be as provided.
125: */
126: ::method "put"
127: use strict arg value, key
128: index = self~caselessIndex(key)
129: self~put:super(value, index)
130: exit
131:
132: /**
133: * Same as the super class, but with the caseless match
134: */
135: ::method "remove"
136: use strict arg key
137: index = self~caselessIndex(key)
138: return self~remove:super(index)
139:
140: /**
141: * The "unknown" method allows processing as for an ooRexx standard
142: * .stringTable, like myCaselessStringtable~firstName="Mike"
143: */
144: ::method "unknown"
145: use arg key, args
146: index = self~caselessIndex(key~strip('T','='))
147: if key~endsWith("=")
148: then self~put:super(args[1],index)
149: else return self~at:super(index)
150: exit
151:
152: /**
153: * Following are the methods to support the .stringTable "ENTRY" methods.
154: * I have not tested these.
155: */
156: ::method "setEntry"
157: use strict arg key, value=.nil
158: index = self~caselessIndex(key)
159: self~setEntry:super(index, value)
160: exit
161:
162: ::method "entry"
163: use strict arg key
164: index = self~caselessIndex(key)
165: return self~entry:super(index)
166:
167: ::method "hasEntry"
168: use strict arg key
169: index = self~caselessIndex(key)
170: return self~hasEntry:super(index)
171: exit
172:
173: ::method "removeEntry"
174: use strict arg key
175: index = self~caselessIndex(key)
176: return self~removeEntry:super(index)
177:
178: ::routine createMemberList
179: members = (("Zimmerman", "Robert", "Allen"),("Zappa","Frank",),("Cale","J.J.",),("Clapton","Eric","Patrick"))
180: memberList = .list~new
181: do m over members
182: member = .caselessStringTable~new
183: member["Last"] = m[1]
184: member~first = m[2]
185: member["middle"] = m[3]
186: memberList~append(member)
187: end
188: return memberList
189:
190:
