associative arrays / dictionaries in QB64?

[madscijr]

Hey everyone... Happy Friday.
I have another newb question, I'm not finding anything on associative arrays -
does QB64 support associative arrays out of the box,
is there a library or an include file that everyone uses,
or is it just "roll your own"?

For fun I made a crude implementation (see code below).
For my purposes I don't need anything heavy duty,
but if there is a better way I would appreciate knowing...

Thanks

Code: QB64: [Select]

1. ' #############################################################################
2. ' EMULATE AN ASSOCIATIVE ARRAY
3.  
4. ' BASED OFF SOME DISCUSSION AT
5. ' https://www.qb64.org/forum/index.php?topic=1001.15
6.  
7. ' Tries to emulate a simple dictionary / associative array in QB64.
8.  
9. ' Some limitations
10. ' 1. Uses a fixed array size
11. ' 2. Only stores integer values
12. ' 3. Not very efficient (simply appends new keys to the end of the array,
13. '    and searches for them in linear order)
14. ' 4. Requires declaring and passing around 2 arrays
15. '    (one for keys, one for values), instead of a single variable.
16.  
17. ' Questions
18. ' 1. Instead of a fixed size, can we implement this with variable arrays and REDIM?
19. ' 2. How can we get it to store mixed data types?
20. '    We could store the values as string, and have a third array of "type",
21. '    but would we have to manually cast each retrieved value with VAL?
22. ' 3. What are some other ways this could be better implemented?
23.  
24. ' #############################################################################
25.  
26. ' =============================================================================
27. ' GLOBAL DECLARATIONS a$=string, i%=integer, L&=long, s!=single, d#=double
28.  
29. ' boolean constants
30. CONST FALSE = 0
31. CONST TRUE = NOT FALSE
32.  
33. CONST cMax = 40
34.  
35. ' =============================================================================
36. ' GLOBAL VARIABLES
37. DIM ProgramPath$
38. DIM ProgramName$
39.  
40. ' =============================================================================
41. ' INITIALIZE
42. ProgramName$ = MID$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\") + 1)
43. ProgramPath$ = LEFT$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\"))
44.  
45. ' =============================================================================
46. ' RUN TEST
47. TestDictionary
48.  
49. ' =============================================================================
50. ' FINISH
51. SYSTEM ' return control to the operating system
52. PRINT ProgramName$ + " finished."
53. END
54.  
55. ' /////////////////////////////////////////////////////////////////////////////
56.  
57. SUB TestDictionary ()
58.     DIM arrKey(40) AS STRING
59.     DIM arrValue(40) AS INTEGER
60.     DIM iLoop AS INTEGER
61.     DIM bResult AS INTEGER
62.     DIM sKey AS STRING
63.     DIM iValue AS INTEGER
64.     DIM iDefault AS INTEGER
65.     DIM iIndex AS INTEGER
66.  
67.     CLS
68.  
69.     PRINT "-------------------------------------------------------------------------------"
70.     PRINT "Initializing dictionary..."
71.     InitDictionary arrValue()
72.     'PRINT "arrValue(0) = " + cstr$(arrValue(0))
73.  
74.     PRINT: PRINT DumpDictionary$(arrKey(), arrValue()): WaitForEnter
75.  
76.     PRINT "-------------------------------------------------------------------------------"
77.     PRINT "Writing some values..."
78.  
79.     sKey = "apple": iValue = 3:
80.     bResult = SaveDictionary%(arrKey(), arrValue(), sKey, iValue)
81.     PRINT "SaveDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
82.  
83.     sKey = "africa": iValue = 1:
84.     bResult = SaveDictionary%(arrKey(), arrValue(), sKey, iValue)
85.     PRINT "SaveDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
86.  
87.     sKey = "zebra": iValue = 0:
88.     bResult = SaveDictionary%(arrKey(), arrValue(), sKey, iValue)
89.     PRINT "SaveDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
90.  
91.     sKey = "xylophone": iValue = 2:
92.     bResult = SaveDictionary%(arrKey(), arrValue(), sKey, iValue)
93.     PRINT "SaveDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
94.  
95.     sKey = "zebra": iValue = 4:
96.     bResult = SaveDictionary%(arrKey(), arrValue(), sKey, iValue)
97.     PRINT "SaveDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
98.  
99.     PRINT: PRINT DumpDictionary$(arrKey(), arrValue()): WaitForEnter
100.  
101.     PRINT "-------------------------------------------------------------------------------"
102.     PRINT "Deleting some keys..."
103.  
104.     sKey = "zebra": bResult = DeleteKey%(arrKey(), arrValue(), sKey)
105.     PRINT "DeleteKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
106.  
107.     sKey = "nonesuch": bResult = DeleteKey%(arrKey(), arrValue(), sKey)
108.     PRINT "DeleteKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
109.  
110.     sKey = "xylophone": bResult = DeleteKey%(arrKey(), arrValue(), sKey)
111.     PRINT "DeleteKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
112.  
113.     PRINT: PRINT DumpDictionary$(arrKey(), arrValue()): WaitForEnter
114.  
115.     PRINT "-------------------------------------------------------------------------------"
116.     PRINT "Look for keys..."
117.  
118.     sKey = "africa": iIndex = FoundKey%(arrKey(), arrValue(), sKey)
119.     PRINT "FoundKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
120.  
121.     sKey = "xenophobe": iIndex = FoundKey%(arrKey(), arrValue(), sKey)
122.     PRINT "FoundKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
123.  
124.     sKey = "APPLE": iIndex = FoundKey%(arrKey(), arrValue(), sKey)
125.     PRINT "FoundKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
126.  
127.     sKey = "zambia": iIndex = FoundKey%(arrKey(), arrValue(), sKey)
128.     PRINT "FoundKey%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
129.  
130.     PRINT: PRINT DumpDictionary$(arrKey(), arrValue()): WaitForEnter
131.  
132.     PRINT "-------------------------------------------------------------------------------"
133.     PRINT "Retrieving values..."
134.  
135.     sKey = "africa": iDefault = -1
136.     PRINT "ReadDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrKey(), arrValue(), sKey, iDefault))
137.  
138.     sKey = "zebra": iDefault = -3
139.     PRINT "ReadDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrKey(), arrValue(), sKey, iDefault))
140.  
141.     sKey = "apple": iDefault = -2
142.     PRINT "ReadDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrKey(), arrValue(), sKey, iDefault))
143.  
144.     sKey = "nonesuch": iDefault = -4
145.     PRINT "ReadDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrKey(), arrValue(), sKey, iDefault))
146.  
147.     sKey = "xylophone": iDefault = -5
148.     PRINT "ReadDictionary%(arrKey(), arrValue(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrKey(), arrValue(), sKey, iDefault))
149.  
150.     PRINT: PRINT DumpDictionary$(arrKey(), arrValue()): WaitForEnter
151.  
152.     PRINT "-------------------------------------------------------------------------------"
153.     PRINT "This concludes the test of the pseudo-associative array / dictionary."
154.     PRINT
155.  
156.     WaitForEnter
157. END SUB ' TestDictionary
158.  
159. ' /////////////////////////////////////////////////////////////////////////////
160.  
161. SUB WaitForEnter
162.     DIM in$
163.     INPUT "Press <ENTER> to continue", in$
164. END SUB ' WaitForEnter
165.  
166. ' /////////////////////////////////////////////////////////////////////////////
167.  
168. SUB InitDictionary (arrValue( 40) AS INTEGER)
169.     arrValue(0) = 0
170. END SUB ' InitDictionary
171.  
172. ' /////////////////////////////////////////////////////////////////////////////
173.  
174. FUNCTION SaveDictionary% (arrKey( 40) AS STRING, arrValue( 40) AS INTEGER, sKey AS STRING, iValue AS INTEGER)
175.     DIM iLoop AS INTEGER
176.     iIndex = 0
177.     FOR iLoop = 1 TO arrValue(0) ' ubound(arrKey)
178.         IF LCASE$(arrKey(iLoop)) = LCASE$(sKey) THEN
179.             iIndex = iLoop
180.             EXIT FOR
181.         END IF
182.     NEXT iLoop
183.     IF (iIndex > 0) THEN
184.         ' KEY EXISTS, UPDATE VALUE
185.         arrValue(iIndex) = iValue
186.         SaveDictionary% = TRUE
187.     ELSE
188.         ' KEY DOESN'T EXIST, ADD IT
189.  
190.         ' IS THERE ROOM?
191.         iIndex = arrValue(0) + 1
192.         IF iIndex > UBOUND(arrKey) THEN
193.             ' DICTIONARY FULL!
194.             SaveDictionary% = FALSE
195.         ELSE
196.             ' ADD VALUE AND KEY
197.             arrValue(0) = iIndex
198.             arrValue(iIndex) = iValue
199.             arrKey(iIndex) = sKey
200.             SaveDictionary% = TRUE
201.         END IF
202.     END IF
203. END FUNCTION ' SaveDictionary%
204.  
205. ' /////////////////////////////////////////////////////////////////////////////
206.  
207. FUNCTION FoundKey% (arrKey( 40) AS STRING, arrValue( 40) AS INTEGER, sKey AS STRING)
208.     DIM iLoop AS INTEGER
209.     DIM iIndex AS INTEGER
210.  
211.     iIndex = 0
212.     FOR iLoop = 1 TO arrValue(0) ' ubound(arrKey)
213.         IF LCASE$(arrKey(iLoop)) = LCASE$(sKey) THEN
214.             iIndex = iLoop
215.             EXIT FOR
216.         END IF
217.     NEXT iLoop
218.  
219.     FoundKey% = iIndex
220. END FUNCTION ' FoundKey%
221.  
222. ' /////////////////////////////////////////////////////////////////////////////
223.  
224. FUNCTION DeleteKey% (arrKey( 40) AS STRING, arrValue( 40) AS INTEGER, sKey AS STRING)
225.     DIM iLoop AS INTEGER
226.     DIM iIndex AS INTEGER
227.     DIM bResult AS INTEGER
228.  
229.     iIndex = 0
230.     FOR iLoop = 1 TO arrValue(0) ' ubound(arrKey)
231.         IF LCASE$(arrKey(iLoop)) = LCASE$(sKey) THEN
232.             iIndex = iLoop
233.             EXIT FOR
234.         END IF
235.     NEXT iLoop
236.  
237.     IF (iIndex = 0) THEN
238.         bResult = FALSE
239.     ELSE
240.         IF iIndex < arrValue(0) THEN
241.             FOR iLoop = iIndex TO (arrValue(0) - 1)
242.                 arrKey(iLoop) = arrKey(iLoop + 1)
243.                 arrValue(iLoop) = arrValue(iLoop + 1)
244.             NEXT iLoop
245.         END IF
246.         arrValue(0) = arrValue(0) - 1
247.         bResult = TRUE
248.     END IF
249.  
250.     DeleteKey% = bResult
251. END FUNCTION ' DeleteKey%
252.  
253. ' /////////////////////////////////////////////////////////////////////////////
254.  
255. FUNCTION DumpDictionary$ (arrKey( 40) AS STRING, arrValue( 40) AS INTEGER)
256.     DIM iLoop AS INTEGER
257.     DIM sResult AS STRING
258.     sResult = ""
259.     sResult = sResult + "Dictionary size: " + cstr$(arrValue(0)) + CHR$(13)
260.     FOR iLoop = 1 TO arrValue(0) ' ubound(arrKey)
261.         sResult = sResult + "Item(" + CHR$(34) + arrKey(iLoop) + CHR$(34) + ") = " + cstr$(arrValue(iLoop)) + CHR$(13)
262.     NEXT iLoop
263.     DumpDictionary$ = sResult
264. END FUNCTION ' DumpDictionary$
265.  
266. ' /////////////////////////////////////////////////////////////////////////////
267.  
268. FUNCTION ReadDictionary% (arrKey( 40) AS STRING, arrValue( 40) AS INTEGER, sKey AS STRING, iDefault AS INTEGER)
269.     DIM iLoop AS INTEGER
270.     DIM iIndex AS INTEGER
271.  
272.     iIndex = 0
273.     FOR iLoop = 1 TO arrValue(0) ' ubound(arrKey)
274.         IF LCASE$(arrKey(iLoop)) = LCASE$(sKey) THEN
275.             iIndex = iLoop
276.             EXIT FOR
277.         END IF
278.     NEXT iLoop
279.  
280.     IF (iIndex = 0) THEN
281.         ReadDictionary% = iDefault
282.     ELSE
283.         ReadDictionary% = arrValue(iIndex)
284.     END IF
285. END FUNCTION ' ReadDictionary%
286.  
287. ' /////////////////////////////////////////////////////////////////////////////
288.  
289. FUNCTION cstr$ (myValue)
290.     cstr = LTRIM$(RTRIM$(STR$(myValue)))
291. END FUNCTION ' cstr$
292.  
293. ' /////////////////////////////////////////////////////////////////////////////
294.  
295. FUNCTION IIF (Condition, IfTrue, IfFalse)
296.     IF Condition THEN IIF = IfTrue ELSE IIF = IfFalse
297. END FUNCTION
298.  
299. ' /////////////////////////////////////////////////////////////////////////////
300.  
301. FUNCTION IIFSTR$ (Condition, IfTrue$, IfFalse$)
302.     IF Condition THEN IIFSTR$ = IfTrue$ ELSE IIFSTR$ = IfFalse$
303. END FUNCTION
304.  
305. ' /////////////////////////////////////////////////////////////////////////////
306.  

[bplus]

I dont know what app you have in mind but generally I would think User Defined TYPE does a fine job of grouping things associated to each other.

Type Dictionary
   Key as string
   Value as Integer
   (... or a whole slew of things with key)
end Type

[bplus]

Oh ha! I do this:

Code: QB64: [Select]

1. FUNCTION cstr$ (myValue)
2.     cstr = LTRIM$(RTRIM$(STR$(myValue)))
3. END FUNCTION '
4.  

like this:

Code: QB64: [Select]

1. Function TS$(Integer)
2.    TS$ = _TRIM$(STR$(Integer))
3. END FUNCTION

[bplus]

Want to take a shot at sorting a Dictionary by Key or by Value? ;)

Then we could do Binary searches.

[madscijr]

I would think User Defined TYPE does a fine job of grouping things associated to each other.
Type Dictionary
   Key as string
   Value as Integer
   (... or a whole slew of things with key)
end Type

Oh duh, yes. I got a little "dyslexic" about the rule about no arrays in UDTs.
But you can have arrays _of_ UDTs!

Updated code below, works!

Code: QB64: [Select]

1. ' #############################################################################
2. ' EMULATE AN ASSOCIATIVE ARRAY
3.  
4. ' BASED OFF SOME DISCUSSION AT
5. ' https://www.qb64.org/forum/index.php?topic=1001.15
6.  
7. ' Tries to emulate a simple dictionary / associative array in QB64.
8.  
9. ' Some limitations
10. ' 1. Uses a fixed array size
11. ' 2. Only stores integer values
12. ' 3. Not very efficient (simply appends new keys to the end of the array,
13. '    and searches for them in linear order)
14. ' 4. FIXED THANKS TO BPLUS! Requires declaring and passing around 2 arrays
15. '    (one for keys, one for values), instead of a single variable.
16. '    Now we just pass one array of user-defined type with key/value.
17.  
18. ' Questions
19. ' 1. Instead of a fixed size, can we implement this with variable arrays and REDIM?
20. ' 2. How can we get it to store mixed data types?
21. '    We could store the values as string, and have a third array of "type",
22. '    but would we have to manually cast each retrieved value with VAL?
23. ' 3. What are some other ways this could be better implemented?
24.  
25. ' #############################################################################
26.  
27. ' =============================================================================
28. ' GLOBAL DECLARATIONS a$=string, i%=integer, L&=long, s!=single, d#=double
29.  
30. ' boolean constants
31. CONST FALSE = 0
32. CONST TRUE = NOT FALSE
33.  
34. CONST cMax = 40
35.  
36. ' =============================================================================
37. ' UDTs
38.  
39. TYPE Dictionary
40.     Key AS STRING
41.     Value AS INTEGER
42. END TYPE
43.  
44. ' =============================================================================
45. ' GLOBAL VARIABLES
46. DIM ProgramPath$
47. DIM ProgramName$
48.  
49. ' =============================================================================
50. ' INITIALIZE
51. ProgramName$ = MID$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\") + 1)
52. ProgramPath$ = LEFT$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\"))
53.  
54. ' =============================================================================
55. ' RUN TEST
56. TestDictionary
57.  
58. ' =============================================================================
59. ' FINISH
60. SYSTEM ' return control to the operating system
61. PRINT ProgramName$ + " finished."
62. END
63.  
64. ' /////////////////////////////////////////////////////////////////////////////
65.  
66. SUB TestDictionary ()
67.     DIM arrDict(40) AS Dictionary
68.     DIM iLoop AS INTEGER
69.     DIM bResult AS INTEGER
70.     DIM sKey AS STRING
71.     DIM iValue AS INTEGER
72.     DIM iDefault AS INTEGER
73.     DIM iIndex AS INTEGER
74.  
75.     CLS
76.  
77.     PRINT "-------------------------------------------------------------------------------"
78.     PRINT "Initializing dictionary..."
79.     InitDictionary arrDict()
80.     'PRINT "arrDict(0).Value = " + cstr$(arrDict(0).Value)
81.  
82.     PRINT: PRINT DumpDictionary$(arrDict()): WaitForEnter
83.  
84.     PRINT "-------------------------------------------------------------------------------"
85.     PRINT "Writing some values..."
86.  
87.     sKey = "apple": iValue = 3:
88.     bResult = SaveDictionary%(arrDict(), sKey, iValue)
89.     PRINT "SaveDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
90.  
91.     sKey = "africa": iValue = 1:
92.     bResult = SaveDictionary%(arrDict(), sKey, iValue)
93.     PRINT "SaveDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
94.  
95.     sKey = "zebra": iValue = 0:
96.     bResult = SaveDictionary%(arrDict(), sKey, iValue)
97.     PRINT "SaveDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
98.  
99.     sKey = "xylophone": iValue = 2:
100.     bResult = SaveDictionary%(arrDict(), sKey, iValue)
101.     PRINT "SaveDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
102.  
103.     sKey = "zebra": iValue = 4:
104.     bResult = SaveDictionary%(arrDict(), sKey, iValue)
105.     PRINT "SaveDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
106.  
107.     PRINT: PRINT DumpDictionary$(arrDict()): WaitForEnter
108.  
109.     PRINT "-------------------------------------------------------------------------------"
110.     PRINT "Deleting some keys..."
111.  
112.     sKey = "zebra": bResult = DeleteKey%(arrDict(), sKey)
113.     PRINT "DeleteKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
114.  
115.     sKey = "nonesuch": bResult = DeleteKey%(arrDict(), sKey)
116.     PRINT "DeleteKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
117.  
118.     sKey = "xylophone": bResult = DeleteKey%(arrDict(), sKey)
119.     PRINT "DeleteKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
120.  
121.     PRINT: PRINT DumpDictionary$(arrDict()): WaitForEnter
122.  
123.     PRINT "-------------------------------------------------------------------------------"
124.     PRINT "Look for keys..."
125.  
126.     sKey = "africa": iIndex = FoundKey%(arrDict(), sKey)
127.     PRINT "FoundKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
128.  
129.     sKey = "xenophobe": iIndex = FoundKey%(arrDict(), sKey)
130.     PRINT "FoundKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
131.  
132.     sKey = "APPLE": iIndex = FoundKey%(arrDict(), sKey)
133.     PRINT "FoundKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
134.  
135.     sKey = "zambia": iIndex = FoundKey%(arrDict(), sKey)
136.     PRINT "FoundKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
137.  
138.     PRINT: PRINT DumpDictionary$(arrDict()): WaitForEnter
139.  
140.     PRINT "-------------------------------------------------------------------------------"
141.     PRINT "Retrieving values..."
142.  
143.     sKey = "africa": iDefault = -1
144.     PRINT "ReadDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrDict(), sKey, iDefault))
145.  
146.     sKey = "zebra": iDefault = -3
147.     PRINT "ReadDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrDict(), sKey, iDefault))
148.  
149.     sKey = "apple": iDefault = -2
150.     PRINT "ReadDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrDict(), sKey, iDefault))
151.  
152.     sKey = "nonesuch": iDefault = -4
153.     PRINT "ReadDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrDict(), sKey, iDefault))
154.  
155.     sKey = "xylophone": iDefault = -5
156.     PRINT "ReadDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadDictionary%(arrDict(), sKey, iDefault))
157.  
158.     PRINT: PRINT DumpDictionary$(arrDict()): WaitForEnter
159.  
160.     PRINT "-------------------------------------------------------------------------------"
161.     PRINT "This concludes the test of the pseudo-associative array / dictionary."
162.     PRINT
163.  
164.     WaitForEnter
165. END SUB ' TestDictionary
166.  
167. ' /////////////////////////////////////////////////////////////////////////////
168.  
169. SUB WaitForEnter
170.     DIM in$
171.     INPUT "Press <ENTER> to continue", in$
172. END SUB ' WaitForEnter
173.  
174. ' /////////////////////////////////////////////////////////////////////////////
175.  
176. SUB InitDictionary (arrDict( 40) AS Dictionary)
177.     arrDict(0).Value = 0
178. END SUB ' InitDictionary
179.  
180. ' /////////////////////////////////////////////////////////////////////////////
181.  
182. FUNCTION SaveDictionary% (arrDict( 40) AS Dictionary, sKey AS STRING, iValue AS INTEGER)
183.     DIM iLoop AS INTEGER
184.     iIndex = 0
185.     FOR iLoop = 1 TO arrDict(0).Value ' ubound(arrKey)
186.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
187.             iIndex = iLoop
188.             EXIT FOR
189.         END IF
190.     NEXT iLoop
191.     IF (iIndex > 0) THEN
192.         ' KEY EXISTS, UPDATE VALUE
193.         arrDict(iIndex).Value = iValue
194.         SaveDictionary% = TRUE
195.     ELSE
196.         ' KEY DOESN'T EXIST, ADD IT
197.  
198.         ' IS THERE ROOM?
199.         iIndex = arrDict(0).Value + 1
200.         IF iIndex > UBOUND(arrDict) THEN
201.             ' DICTIONARY FULL!
202.             SaveDictionary% = FALSE
203.         ELSE
204.             ' ADD VALUE AND KEY
205.             arrDict(0).Value = iIndex
206.             arrDict(iIndex).Value = iValue
207.             arrDict(iIndex).Key = sKey
208.             SaveDictionary% = TRUE
209.         END IF
210.     END IF
211. END FUNCTION ' SaveDictionary%
212.  
213. ' /////////////////////////////////////////////////////////////////////////////
214.  
215. FUNCTION FoundKey% (arrDict( 40) AS Dictionary, sKey AS STRING)
216.     DIM iLoop AS INTEGER
217.     DIM iIndex AS INTEGER
218.  
219.     iIndex = 0
220.     FOR iLoop = 1 TO arrDict(0).Value ' ubound(arrKey)
221.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
222.             iIndex = iLoop
223.             EXIT FOR
224.         END IF
225.     NEXT iLoop
226.  
227.     FoundKey% = iIndex
228. END FUNCTION ' FoundKey%
229.  
230. ' /////////////////////////////////////////////////////////////////////////////
231.  
232. FUNCTION DeleteKey% (arrDict( 40) AS Dictionary, sKey AS STRING)
233.     DIM iLoop AS INTEGER
234.     DIM iIndex AS INTEGER
235.     DIM bResult AS INTEGER
236.  
237.     iIndex = 0
238.     FOR iLoop = 1 TO arrDict(0).Value ' ubound(arrKey)
239.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
240.             iIndex = iLoop
241.             EXIT FOR
242.         END IF
243.     NEXT iLoop
244.  
245.     IF (iIndex = 0) THEN
246.         bResult = FALSE
247.     ELSE
248.         IF iIndex < arrDict(0).Value THEN
249.             FOR iLoop = iIndex TO (arrDict(0).Value - 1)
250.                 arrDict(iLoop).Key = arrDict(iLoop + 1).Key
251.                 arrDict(iLoop).Value = arrDict(iLoop + 1).Value
252.             NEXT iLoop
253.         END IF
254.         arrDict(0).Value = arrDict(0).Value - 1
255.         bResult = TRUE
256.     END IF
257.  
258.     DeleteKey% = bResult
259. END FUNCTION ' DeleteKey%
260.  
261. ' /////////////////////////////////////////////////////////////////////////////
262.  
263. FUNCTION DumpDictionary$ (arrDict( 40) AS Dictionary)
264.     DIM iLoop AS INTEGER
265.     DIM sResult AS STRING
266.     sResult = ""
267.     sResult = sResult + "Dictionary size: " + cstr$(arrDict(0).Value) + CHR$(13)
268.     FOR iLoop = 1 TO arrDict(0).Value ' ubound(arrKey)
269.         sResult = sResult + "Item(" + CHR$(34) + arrDict(iLoop).Key + CHR$(34) + ") = " + cstr$(arrDict(iLoop).Value) + CHR$(13)
270.     NEXT iLoop
271.     DumpDictionary$ = sResult
272. END FUNCTION ' DumpDictionary$
273.  
274. ' /////////////////////////////////////////////////////////////////////////////
275.  
276. FUNCTION ReadDictionary% (arrDict( 40) AS Dictionary, sKey AS STRING, iDefault AS INTEGER)
277.     DIM iLoop AS INTEGER
278.     DIM iIndex AS INTEGER
279.  
280.     iIndex = 0
281.     FOR iLoop = 1 TO arrDict(0).Value ' ubound(arrDict)
282.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
283.             iIndex = iLoop
284.             EXIT FOR
285.         END IF
286.     NEXT iLoop
287.  
288.     IF (iIndex = 0) THEN
289.         ReadDictionary% = iDefault
290.     ELSE
291.         ReadDictionary% = arrDict(iIndex).Value
292.     END IF
293. END FUNCTION ' ReadDictionary%
294.  
295. ' /////////////////////////////////////////////////////////////////////////////
296.  
297. FUNCTION cstr$ (myValue)
298.     cstr = LTRIM$(RTRIM$(STR$(myValue)))
299. END FUNCTION ' cstr$
300.  
301. ' /////////////////////////////////////////////////////////////////////////////
302.  
303. FUNCTION IIF (Condition, IfTrue, IfFalse)
304.     IF Condition THEN IIF = IfTrue ELSE IIF = IfFalse
305. END FUNCTION
306.  
307. ' /////////////////////////////////////////////////////////////////////////////
308.  
309. FUNCTION IIFSTR$ (Condition, IfTrue$, IfFalse$)
310.     IF Condition THEN IIFSTR$ = IfTrue$ ELSE IIFSTR$ = IfFalse$
311. END FUNCTION
312.  
313. ' /////////////////////////////////////////////////////////////////////////////
314.  

[madscijr]

Oh ha! I do this:
...

Code: QB64: [Select]

1. Function TS$(Integer)
2.    TS$ = _TRIM$(STR$(Integer))
3. END FUNCTION

Oh duh, there is a _TRIM$ function after all! Thanks.

Followup question on that, I don't see anything about QB64 supporting "variant" types.
Does that parameter accept values other than just integer?

[madscijr]

Want to take a shot at sorting a Dictionary by Key or by Value? ;)
Then we could do Binary searches.

I have various VBA and VB6 sorting routines laying around, not sure how much of that stuff needs to be reworked for QB64.

One thing I am kind of fuzzy on, and have avoided so far in QB64 due to laziness & not wanting to get caught up right now in details, is dynamic array stuff. I was getting these frustrating errors with using REDIM, so I just avoided dynamic arrays. That probably won't be necessary for sorting, but it might make the dictionary implementation better. Also, if we want to create a copy of an array, how would we DIM it dynamically to match the size of the original array? I haven't really dove into any of that yet...
Thanks

[bplus]

But you can have arrays _of_ UDTs!

Yes, that's the best part! Only one caveat, you can't file them if they have variable length strings. Oh, another, Functions can not return UDT's.

Followup question on that ((FUNCTION) TS$ = _TRIM$(STR$(AnInteger)), I don't see anything about QB64 supporting "variant" types.
Does that parameter accept values other than just integer?

No variant type, not in QB64 which gets all our code translated to C+ and then compiled, so pretty formal with variable types.
SmallBASIC (not MS version: Small Basic) is really cool with variant type, you don't even have to pre-define your UDT's! but it is Interpreter only and has miserable IDE (from Right mouse popup menu) nice on Android though.

PS yeah be careful with undeclared types in Function definitions, make sure it is what you are using for default Type.
New ideas LONG Type works as fast or faster than INTEGER Type as Dynamic arrays are just as fast as STATIC so unless there is some really special case use Default Single or DEFLNG A-Z for all LONGs as default variable Type and REDIM for arrays because Dynamic are more powerful because they can be changed in size without losing data.

I was getting these frustrating errors with using REDIM, so I just avoided dynamic arrays.

Yeah so if you are having problems with Dynamic arrays, let's get them straighten out to save time and grief in future and get you up to date with QB64.

I think the main key here is always start an array as REDIM not DIM! Even though there is nothing to RE do, that's the only way to start a Dynamic array. Once it's Dynamic you can erase (without ERASE that you need for DIM MyStaticArray(nItems) with another REDIM myDynamicArray(nItems) or save data and change size REDIM _PRESERVE myDynamicArray(nItems + nNewItems).


BTW copying an array is a weakness for QB64 ( You cant just say B$() = A$() ) but I have routine using _Mem that works for arrays that aren't strings and there is another way for arrays with strings ie check with SMcNeill the _MEM master :) Funny I haven't needed that so much.
And for sorting, I have a QuickSort routine I modify for what ever type the array is and what the sort key type is.

[bplus]

Oh I just got around to testing Dictionary Tools

This is interesting,
  [ You are not allowed to view this attachment ]  

You aren't just returning 0 if not found, plus you have to input a "search" place along with search item?

[madscijr]

Oh I just got around to testing Dictionary Tools
This is interesting,
  [ You are not allowed to view this attachment ]  
You aren't just returning 0 if not found, plus you have to input a "search" place along with search item?

No, the second parameter lets you specify a default value to return if the key is not found, that's all.
For my purposes, that usually saves some coding.

[madscijr]

Yeah so if you are having problems with Dynamic arrays, let's get them straighten out to save time and grief in future and get you up to date with QB64.

I think the main key here is always start an array as REDIM not DIM! Even though there is nothing to RE do, that's the only way to start a Dynamic array. Once it's Dynamic you can erase (without ERASE that you need for DIM MyStaticArray(nItems) with another REDIM myDynamicArray(nItems) or save data and change size REDIM _PRESERVE myDynamicArray(nItems + nNewItems).

Thanks for explaining. I recoded it to use dynamic arrays, and now it's much cleaner! (Updated code below.)

BTW copying an array is a weakness for QB64 ( You cant just say B$() = A$() ) but I have routine using _Mem that works for arrays that aren't strings and there is another way for arrays with strings ie check with SMcNeill the _MEM master :) Funny I haven't needed that so much.
And for sorting, I have a QuickSort routine I modify for what ever type the array is and what the sort key type is.

I saw some mention of the _MEM or mem copy functions -
how "brittle" is code that relies on it? Will it work across platforms (on Mac or Linux)?
If you can post an example function to copy an array of these

Code: QB64: [Select]

1. Type IntDictionary
2.    Key as string
3.    Value as Integer
4. End Type
5.  

and an array of these

Code: QB64: [Select]

1. Type StrDictionary
2.    Key AS STRING
3.    Value AS STRING
4. End Type
5.  

then I can try to add a "copy" function.
(Though for my purposes, just iterating through it, and doing a straight copy should be fast enough. I am more just curious.)

Anyway here is the updated dictionary code with dynamic arrays:

Code: QB64: [Select]

1. ' #############################################################################
2. ' EMULATE AN ASSOCIATIVE ARRAY
3.  
4. ' BASED OFF SOME DISCUSSION AT
5. ' https://www.qb64.org/forum/index.php?topic=1001.15
6.  
7. ' Tries to emulate a simple dictionary / associative array in QB64.
8.  
9. ' Some limitations
10. ' 1. FIXED THANKS TO BPLUS! Uses a fixed array size
11. ' 2. Only stores integer values. To store other types, just make a copy
12. '    and modify the types and function names. Currently the
13. '    naming convention is pretty clunky, but it is unambiguous!
14. ' 3. Not very efficient (simply appends new keys to the end of the array,
15. '    and searches for them in linear order)
16. ' 4. FIXED THANKS TO BPLUS! Requires declaring and passing around 2 arrays
17. '    (one for keys, one for values), instead of a single variable.
18. '    Now we just pass one array of user-defined type with key/value.
19. ' 5. No sorting.
20. '
21. ' Questions
22. ' 1. YES THANKS BPLUS! Instead of a fixed size, can we implement this with
23. '    variable arrays and REDIM?
24. ' 2. How can we get it to store mixed data types?
25. '    We could store the values as string, and have a third array of "type",
26. '    but would we have to manually cast each retrieved value with VAL?
27. '    A lazy way of doing it could be add values to the Dictionary UDT
28. '    to hold each type, so we have:
29. '        Type Dictionary
30. '            Key AS STRING
31. '            Type AS STRING ' specifies type ("$", "%", "&", "!", or "#")
32. '                           ' (or make this type int and use constants)
33. '            strValue AS STRING
34. '            intValue AS INTEGER
35. '            lngValue AS LONG
36. '            sngValue AS SINGLE
37. '            dblValue AS DOUBLE
38. '            etc.
39. '        End Type
40. '    and have functions like ReadDictionaryString, WriteDictionaryString,
41. '    ReadDictionaryInt, WriteDictionaryInt, etc. Theoretically one key could
42. '    point to multiple values. Just add what you want. Kind of wasteful,
43. '    and a very lazy way to implement it, but simple multipurpose design?
44. '    We could implement an in-memory database, or structures like STxAxTIC
45. '    discusses here: https://www.qb64.org/forum/index.php?topic=2447.0
46. '    The sky is the limit! So many possibilities, but I just needed a simple
47. '    way to do an associative array / dictionary for a relatively small number
48. '    of keys, so for now I think it's easier to just make separate
49. '    dictionary functions/types for each variable type you want to store.
50. ' 3. Would it be more efficient if we inserted elements in sort order,
51. '    so the dictionary is always sorted? That would speed up read (which would
52. '    find the key with a binary search) but slow down write.
53. ' 4. If we added a sort function, to sort by value OR key?
54. '    Which algorithm would be fast (but not too complex to debug &
55. '    understand) for integer values? For string values?
56. ' 5. What are some other ways this could be better implemented?
57.  
58. ' #############################################################################
59.  
60. ' =============================================================================
61. ' GLOBAL DECLARATIONS a$=string, i%=integer, L&=long, s!=single, d#=double
62.  
63. ' boolean constants
64. CONST FALSE = 0
65. CONST TRUE = NOT FALSE
66.  
67. CONST cIntDictMax = 255 ' lets us limit the size of the dictionary
68.  
69. ' =============================================================================
70. ' UDTs
71.  
72. TYPE IntDictionary
73.     Key AS STRING
74.     Value AS INTEGER
75. END TYPE
76.  
77. ' =============================================================================
78. ' GLOBAL VARIABLES
79. DIM ProgramPath$
80. DIM ProgramName$
81.  
82. ' =============================================================================
83. ' INITIALIZE
84. ProgramName$ = MID$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\") + 1)
85. ProgramPath$ = LEFT$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\"))
86.  
87. ' =============================================================================
88. ' RUN TEST
89. TestIntDictionary
90.  
91. ' =============================================================================
92. ' FINISH
93. SYSTEM ' return control to the operating system
94. PRINT ProgramName$ + " finished."
95. END
96.  
97. ' /////////////////////////////////////////////////////////////////////////////
98.  
99. SUB TestIntDictionary ()
100.     REDIM arrDict(-1) AS IntDictionary
101.     DIM iLoop AS INTEGER
102.     DIM bResult AS INTEGER
103.     DIM sKey AS STRING
104.     DIM iValue AS INTEGER
105.     DIM iDefault AS INTEGER
106.     DIM iIndex AS INTEGER
107.  
108.     CLS
109.  
110.     PRINT "-------------------------------------------------------------------------------"
111.     PRINT "Initializing integer-value dictionary..."
112.     InitIntDictionary arrDict()
113.     'PRINT "arrDict(0).Value = " + cstr$(arrDict(0).Value)
114.  
115.     PRINT: PRINT DumpIntDictionary$(arrDict()): WaitForEnter
116.  
117.     PRINT "-------------------------------------------------------------------------------"
118.     PRINT "Writing some values..."
119.  
120.     sKey = "apple": iValue = 3:
121.     bResult = SaveIntDictionary%(arrDict(), sKey, iValue)
122.     PRINT "SaveIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
123.  
124.     sKey = "africa": iValue = 1:
125.     bResult = SaveIntDictionary%(arrDict(), sKey, iValue)
126.     PRINT "SaveIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
127.  
128.     sKey = "zebra": iValue = 0:
129.     bResult = SaveIntDictionary%(arrDict(), sKey, iValue)
130.     PRINT "SaveIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
131.  
132.     sKey = "xylophone": iValue = 2:
133.     bResult = SaveIntDictionary%(arrDict(), sKey, iValue)
134.     PRINT "SaveIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
135.  
136.     sKey = "zebra": iValue = 4:
137.     bResult = SaveIntDictionary%(arrDict(), sKey, iValue)
138.     PRINT "SaveIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iValue) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
139.  
140.     PRINT: PRINT DumpIntDictionary$(arrDict()): WaitForEnter
141.  
142.     PRINT "-------------------------------------------------------------------------------"
143.     PRINT "Deleting some keys..."
144.  
145.     sKey = "zebra": bResult = DeleteIntDictionaryKey%(arrDict(), sKey)
146.     PRINT "DeleteIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
147.  
148.     sKey = "nonesuch": bResult = DeleteIntDictionaryKey%(arrDict(), sKey)
149.     PRINT "DeleteIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
150.  
151.     sKey = "xylophone": bResult = DeleteIntDictionaryKey%(arrDict(), sKey)
152.     PRINT "DeleteIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + IIFSTR$(bResult, "TRUE", "FALSE")
153.  
154.     PRINT: PRINT DumpIntDictionary$(arrDict()): WaitForEnter
155.  
156.     PRINT "-------------------------------------------------------------------------------"
157.     PRINT "Look for keys..."
158.  
159.     sKey = "africa": iIndex = FoundIntDictionaryKey%(arrDict(), sKey)
160.     PRINT "FoundIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
161.  
162.     sKey = "xenophobe": iIndex = FoundIntDictionaryKey%(arrDict(), sKey)
163.     PRINT "FoundIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
164.  
165.     sKey = "APPLE": iIndex = FoundIntDictionaryKey%(arrDict(), sKey)
166.     PRINT "FoundIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
167.  
168.     sKey = "zambia": iIndex = FoundIntDictionaryKey%(arrDict(), sKey)
169.     PRINT "FoundIntDictionaryKey%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ") returns " + cstr$(iIndex) + " which evaluates to " + IIFSTR$(iIndex, "TRUE", "FALSE")
170.  
171.     PRINT: PRINT DumpIntDictionary$(arrDict()): WaitForEnter
172.  
173.     PRINT "-------------------------------------------------------------------------------"
174.     PRINT "Retrieving values..."
175.  
176.     sKey = "africa": iDefault = -1
177.     PRINT "ReadIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadIntDictionary%(arrDict(), sKey, iDefault))
178.  
179.     sKey = "zebra": iDefault = -3
180.     PRINT "ReadIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadIntDictionary%(arrDict(), sKey, iDefault))
181.  
182.     sKey = "apple": iDefault = -2
183.     PRINT "ReadIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadIntDictionary%(arrDict(), sKey, iDefault))
184.  
185.     sKey = "nonesuch": iDefault = -4
186.     PRINT "ReadIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadIntDictionary%(arrDict(), sKey, iDefault))
187.  
188.     sKey = "xylophone": iDefault = -5
189.     PRINT "ReadIntDictionary%(arrDict(), " + CHR$(34) + sKey + CHR$(34) + ", " + cstr$(iDefault) + ") returns: " + cstr$(ReadIntDictionary%(arrDict(), sKey, iDefault))
190.  
191.     PRINT: PRINT DumpIntDictionary$(arrDict()): WaitForEnter
192.  
193.     PRINT "-------------------------------------------------------------------------------"
194.     PRINT "This concludes the test of the pseudo-associative array / integer dictionary."
195.     PRINT
196.  
197.     WaitForEnter
198. END SUB ' TestIntDictionary
199.  
200. ' /////////////////////////////////////////////////////////////////////////////
201.  
202. SUB WaitForEnter
203.     DIM in$
204.     INPUT "Press <ENTER> to continue", in$
205. END SUB ' WaitForEnter
206.  
207. ' /////////////////////////////////////////////////////////////////////////////
208.  
209. SUB InitIntDictionary (arrDict() AS IntDictionary)
210.     REDIM arrDict(-1) AS IntDictionary
211.     'arrDict(0).Value = 0
212. END SUB ' InitIntDictionary
213.  
214. ' /////////////////////////////////////////////////////////////////////////////
215.  
216. FUNCTION SaveIntDictionary% (arrDict() AS IntDictionary, sKey AS STRING, iValue AS INTEGER)
217.     DIM iLoop AS INTEGER
218.     DIM iIndex AS INTEGER
219.     iIndex = -1
220.     FOR iLoop = 0 TO UBOUND(arrDict)
221.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
222.             iIndex = iLoop
223.             EXIT FOR
224.         END IF
225.     NEXT iLoop
226.     IF (iIndex > -1) THEN
227.         ' KEY EXISTS, UPDATE VALUE
228.         arrDict(iIndex).Value = iValue
229.         SaveIntDictionary% = TRUE
230.     ELSE
231.         ' KEY DOESN'T EXIST, ADD IT
232.  
233.         ' IS THERE ROOM?
234.         iIndex = UBOUND(arrDict) + 1
235.         IF iIndex > cIntDictMax THEN
236.             ' DICTIONARY FULL!
237.             SaveIntDictionary% = FALSE
238.         ELSE
239.             ' ADD VALUE AND KEY
240.             REDIM _PRESERVE arrDict(iIndex) AS IntDictionary
241.             arrDict(iIndex).Value = iValue
242.             arrDict(iIndex).Key = sKey
243.             SaveIntDictionary% = TRUE
244.         END IF
245.     END IF
246. END FUNCTION ' SaveIntDictionary%
247.  
248. ' /////////////////////////////////////////////////////////////////////////////
249.  
250. FUNCTION FoundIntDictionaryKey% (arrDict() AS IntDictionary, sKey AS STRING)
251.     DIM iLoop AS INTEGER
252.     DIM iIndex AS INTEGER
253.  
254.     iIndex = -1
255.     FOR iLoop = 0 TO UBOUND(arrDict)
256.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
257.             iIndex = iLoop
258.             EXIT FOR
259.         END IF
260.     NEXT iLoop
261.  
262.     FoundIntDictionaryKey% = iIndex
263. END FUNCTION ' FoundIntDictionaryKey%
264.  
265. ' /////////////////////////////////////////////////////////////////////////////
266.  
267. FUNCTION DeleteIntDictionaryKey% (arrDict() AS IntDictionary, sKey AS STRING)
268.     DIM iLoop AS INTEGER
269.     DIM iIndex AS INTEGER
270.     DIM bResult AS INTEGER
271.  
272.     iIndex = -1
273.     FOR iLoop = 0 TO UBOUND(arrDict)
274.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
275.             iIndex = iLoop
276.             EXIT FOR
277.         END IF
278.     NEXT iLoop
279.  
280.     IF (iIndex > -1) THEN
281.         IF iIndex < UBOUND(arrDict) THEN
282.             FOR iLoop = (UBOUND(arrDict) - 1) TO iIndex STEP -1
283.                 arrDict(iLoop).Key = arrDict(iLoop + 1).Key
284.                 arrDict(iLoop).Value = arrDict(iLoop + 1).Value
285.             NEXT iLoop
286.         END IF
287.         REDIM _PRESERVE arrDict(UBOUND(arrDict) - 1) AS IntDictionary
288.         bResult = TRUE
289.     ELSE
290.         bResult = FALSE
291.     END IF
292.  
293.     DeleteIntDictionaryKey% = bResult
294. END FUNCTION ' DeleteIntDictionaryKey%
295.  
296. ' /////////////////////////////////////////////////////////////////////////////
297.  
298. FUNCTION DumpIntDictionary$ (arrDict() AS IntDictionary)
299.     DIM iLoop AS INTEGER
300.     DIM sResult AS STRING
301.     sResult = ""
302.     sResult = sResult + "IntDictionary size: " + cstr$(UBOUND(arrDict) + 1) + CHR$(13)
303.     FOR iLoop = 0 TO UBOUND(arrDict)
304.         sResult = sResult + "Item(" + CHR$(34) + arrDict(iLoop).Key + CHR$(34) + ") = " + cstr$(arrDict(iLoop).Value) + CHR$(13)
305.     NEXT iLoop
306.     DumpIntDictionary$ = sResult
307. END FUNCTION ' DumpIntDictionary$
308.  
309. ' /////////////////////////////////////////////////////////////////////////////
310.  
311. FUNCTION ReadIntDictionary% (arrDict() AS IntDictionary, sKey AS STRING, iDefault AS INTEGER)
312.     DIM iLoop AS INTEGER
313.     DIM iIndex AS INTEGER
314.  
315.     iIndex = -1
316.     FOR iLoop = 0 TO UBOUND(arrDict)
317.         IF LCASE$(arrDict(iLoop).Key) = LCASE$(sKey) THEN
318.             iIndex = iLoop
319.             EXIT FOR
320.         END IF
321.     NEXT iLoop
322.  
323.     IF (iIndex > -1) THEN
324.         ReadIntDictionary% = arrDict(iIndex).Value
325.     ELSE
326.         ReadIntDictionary% = iDefault
327.     END IF
328. END FUNCTION ' ReadIntDictionary%
329.  
330. ' /////////////////////////////////////////////////////////////////////////////
331.  
332. FUNCTION cstr$ (myValue)
333.     cstr = LTRIM$(RTRIM$(STR$(myValue)))
334. END FUNCTION ' cstr$
335.  
336. ' /////////////////////////////////////////////////////////////////////////////
337.  
338. FUNCTION IIF (Condition, IfTrue, IfFalse)
339.     IF Condition THEN IIF = IfTrue ELSE IIF = IfFalse
340. END FUNCTION
341.  
342. ' /////////////////////////////////////////////////////////////////////////////
343.  
344. FUNCTION IIFSTR$ (Condition, IfTrue$, IfFalse$)
345.     IF Condition THEN IIFSTR$ = IfTrue$ ELSE IIFSTR$ = IfFalse$
346. END FUNCTION
347.  
348. ' /////////////////////////////////////////////////////////////////////////////
349.  

[bplus]

I saw some mention of the _MEM or mem copy functions -
how "brittle" is code that relies on it? Will it work across platforms (on Mac or Linux)?
If you can post an example function to copy an array of these

@madscijr

_MEM functions are all cross platform I am pretty sure, maybe _MEM Master will confirm :-))

You got me about copying a UDT Array! ;(  Maybe the _MEM Master will help us with that too. :)

The tedious standard way of copying should be fine for smaller arrays of UDT's if you have a serious sized UDT array with serious application you might have to consider dedicated Data-basing Apps.

I am wondering what you use Dictionary style coding for? (if you dont mind talking about it).

[madscijr]

@madscijr
I am wondering what you use Dictionary style coding for? (if you dont mind talking about it).

I use associative arrays for a million things, they are especially useful in vbscripts and VBA macros for MS Office (you have to reference the microsoft.scripting.runtime, then you can use scripting.dictionary).
But for my purposes in QB64 I'm making a simple video game where you can define the sprites using simple strings, like this:

Code: QB64: [Select]

1.     ' A 16x16 "sprite":
2.     sGraphic = ""
3.     sGraphic = sGraphic + "................" + CHR$(13)
4.     sGraphic = sGraphic + "................" + CHR$(13)
5.     sGraphic = sGraphic + "................" + CHR$(13)
6.     sGraphic = sGraphic + "................" + CHR$(13)
7.     sGraphic = sGraphic + "................" + CHR$(13)
8.     sGraphic = sGraphic + "................" + CHR$(13)
9.     sGraphic = sGraphic + ".........###...." + CHR$(13)
10.     sGraphic = sGraphic + "....######.#...." + CHR$(13)
11.     sGraphic = sGraphic + "....#.#..###...." + CHR$(13)
12.     sGraphic = sGraphic + "................" + CHR$(13)
13.     sGraphic = sGraphic + "................" + CHR$(13)
14.     sGraphic = sGraphic + "................" + CHR$(13)
15.     sGraphic = sGraphic + "................" + CHR$(13)
16.     sGraphic = sGraphic + "................" + CHR$(13)
17.     sGraphic = sGraphic + "................" + CHR$(13)
18.     sGraphic = sGraphic + "................" '+ chr$(13)
19.  

Where the "#" character is associated with the color black,
"R" with red , "B" with blue, "G" with green, "Y" yellow,
"W" white, "." transparent, etc.
Basically it makes it easy to "draw" sprites inside the QB64 editor,
and kind of visualize what you're getting.
I wanted it to be a "type in program" friendly way of doing it,
without relying on an external graphics program,
or hard to read method of storing the graphic data
(even if it's more efficient). There aren't so many sprites
and complicated graphics to where this would be a problem.
And there can be multiple copies of each sprite, in different color.

I also use constants to store the color values, like

Code: QB64: [Select]

1. CONST cRed = _RGB32(255, 0, 0)
2. CONST cLime = _RGB32(0, 255, 0)
3. CONST cBlue = _RGB32(0, 0, 255)
4. CONST cYellow = _RGB32(255, 255, 0)
5. CONST cOrange = _RGB32(255, 165, 0)
6. CONST cPurple = _RGB32(128, 0, 255)
7. CONST cBlack = _RGB32(0, 0, 0)
8. CONST cWhite = _RGB32(255, 255, 255)
9. CONST cGreen = _RGB32(0, 128, 0)
10. CONST cEmpty = -1
11.  

I wanted an easy way to map the color contants to the different letters used in the textual representation of the sprites, so for instance, I could easily remap "G" from lime green #00FF00 to darker green #008000. So I just use an associative array to map the letters to the given colors:

Code: QB64: [Select]

1. FUNCTION GetColorDictionary% (arrColorValue() AS IntDictionary)
2.     DIM bResult AS INTEGER
3.     DIM iErrorCount AS INTEGER
4.     InitIntDictionary arrColorValue()
5.     iErrorCount = 0
6.     iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "R", cRed), 0, 1)
7.     iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "Y", cYellow), 0, 1)
8.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "G", cLime), 0, 1)
9.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "B", cBlue), 0, 1)
10.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "O", cOrange), 0, 1)
11.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "P", cPurple), 0, 1)
12.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "W", cWhite), 0, 1)
13.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), "#", cBlack), 0, 1)
14.         iErrorCount = iErrorCount + IIF(SaveIntDictionary%(arrColorValue(), ".", cEmpty), 0, 1)
15.         'ETC
16.     GetColorDictionary% = IIF(iErrorCount = 0, TRUE, FALSE)
17. END SUB ' GetColorDictionary%
18.  

I know it's not the standard way of doing things, but I just wanted to make this game graphics able to be edited by "drawing" the sprites in simple text inside the source code!

I'm sure I will put dictionaries to use in more conventional ways too! LoL

[bplus]

OK I wouldn't have guessed graphics ;-)) thanks.

Yeah, I dont think we Basic users are very conventional, more like Do-It-Yourselfers. :)

[madscijr]

OK I wouldn't have guessed graphics ;-)) thanks.
Yeah, I dont think we Basic users are very conventional, more like Do-It-Yourselfers. :)

Well as you know with computer programming, you can build stuff however you like!

What will be great, will be when AI gets smart enough, that we can create our own languages without having to actually program low-level code. Just tell the AI in plain English what you want the syntax to be like, etc., and it will create a compiler for that. And eventually the tools will be smart enough to where they can translate code written in one programming language into some other language (and paradigm!) of your choice. That's coming, but I'm not holding my breath!