Dictionary in action

The elements of dictionaries are allocated automatically by the runtime system. Dictionary elements are accessed by key:

MAIN
  DEFINE dict DICTIONARY OF DECIMAL(10,2)
  LET dict["bananas"] = 10540.45
  LET dict["apples"]  =  3487.55
  LET dict["oranges"] =   234.10
  DISPLAY dict.getLength()  -- Shows 3
END MAIN

Keys are used in dictionary subscripts. The key value must be enclosed in square brackets:

LET dict[ "the key" ].member = value

The DICTIONARY class provides following methods related to keys:

• To check if a key exists, use the contains() method.
• To delete an element, use the remove() method.
• To get all keys of a dictionary, use the getKeys() method.

The elements of a dictionary variable are typically defined with simple data types, with a structured record, or with a user-defined type:

TYPE t_contact RECORD
       name VARCHAR(30),
       address VARCHAR(100),
       birth DATE
     END RECORD
MAIN
  DEFINE contact DICTIONARY OF t_contact
  LET contact["EFC456"].name = "Mike Campbell"
  LET contact["EFC456"].address = "5, Big tree St."
  LET contact["EFC456"].birth = MDY(10,23,1999)
  DISPLAY contact["EFC456"].*
END MAIN

Dictionaries can also be combined with another collection type, such as a dynamic array, or another dictionary:

MAIN
    DEFINE d DICTIONARY OF DYNAMIC ARRAY OF DECIMAL(10,2)
    LET d["march"][12] = 456.25
END MAIN

Similarly, when used in an expression, the element will be automatically allocated if it does not exist, and the element value will evaluate to NULL:

MAIN
  DEFINE dict DICTIONARY OF INTEGER
  DISPLAY (dict["unexisting"] IS NULL) -- shows 1 (TRUE)
END MAIN

MAIN
  DEFINE dict DICTIONARY OF INTEGER
  LET dict["id1"] = 33  -- Created automatically
  DISPLAY dict["id2"]   -- Created automatically
  IF dict.contains("id3") THEN
     DISPLAY dict["id3"]  -- Not displayed as it does not exist
  END IF
END MAIN

The dictionary can be modified inside the called function, and the caller will see the modifications.

MAIN
  DEFINE dict DICTIONARY OF INTEGER
  CALL fill(dict)
  DISPLAY dict.getLength() -- shows 2
END MAIN

FUNCTION fill(x)
  DEFINE x DICTIONARY OF INTEGER
  LET x["ABC"] = 123
  LET x["DEF"] = 456
END FUNCTION

DICTIONARY variables are not comparable: Comparing two DICTIONARY variable, or using a dictionary in any expression, will produce the compiler error -4340:

MAIN
  DEFINE d1, d2 DICTIONARY OF INTEGER
  LET d1["ABC"] = 123
  LET d2["DEF"] = 456
  DISPLAY "1:", (d1 == d2)
| The variable 'd1' is too complex a type to be used in an expression.
| See error number -4340.
| The variable 'd2' is too complex a type to be used in an expression.
| See error number -4340.
END MAIN

When comparing records with a rec1.* == rec2.* expression, if the record type contains DICTIONARY members, the comparison always evaluates to FALSE:

MAIN
    DEFINE r1, r2 RECORD
               pkey INTEGER,
               dic DICTIONARY OF STRING
           END RECORD
    LET r1.pkey = 101
    LET r1.dic["aaa"] = "xxx"
    LET r2.pkey = 101
    LET r2.dic["aaa"] = "xxx"
    DISPLAY IIF( r1.* == r2.*, "TRUE", "FALSE" )  -- Shows "FALSE"
END MAIN