9 replies to this topic

[rbrtryn]

Normally, looping through the keys in an associative array will present them in alphabetical order as in this script:

Array := Object("b", "1st", "a", "2nd")
For Key, Value in Array
    MsgBox %Key%, %Value%

For some applications, however, it is important that the keys be presented in the order that they were created. I the script above, for instance, b, 1st was probably wanted before a, 2nd. Searching the forums, I found this post buried in the support section from two years ago.

I took up Lexikos' challenge and added the .Insert(), .InsertBefore() and .Remove() methods. I also changed the __set method to allow the array to be sub-classed if necessary.

Examples assume OrderedArray() is in one of your Standard Libraries.

The function:

Spoiler

; OrderedArray code by Lexikos
; Modifications and additional methods by rbrtryn
; http://tinyurl.com/lhtvalv
OrderedArray(prm*)
{
    ; Define prototype object for ordered arrays:
    static base := Object("__Set", "oaSet", "_NewEnum", "oaNewEnum"
                        , "Remove", "oaRemove", "Insert", "oaInsert", "InsertBefore", "oaInsertBefore")
    ; Create and return new ordered array object:
    return Object("_keys", Object(), "base", base, prm*)
}

oaSet(obj, prm*)
{
    ; If this function is called, the key must not already exist.
    ; Sub-class array if necessary then add this new key to the key list
    if prm.maxindex() > 2
        ObjInsert(obj, prm[1], OrderedArray())
    ObjInsert(obj._keys, prm[1])
    ; Since we don't return a value, the default behaviour takes effect.
    ; That is, a new key-value pair is created and stored in the object.
}

oaNewEnum(obj)
{
    ; Define prototype object for custom enumerator:
    static base := Object("Next", "oaEnumNext")
    ; Return an enumerator wrapping our _keys array's enumerator:
    return Object("obj", obj, "enum", obj._keys._NewEnum(), "base", base)
}

oaEnumNext(e, ByRef k, ByRef v="")
{
    ; If Enum.Next() returns a "true" value, it has stored a key and
    ; value in the provided variables. In this case, "i" receives the
    ; current index in the _keys array and "k" receives the value at
    ; that index, which is a key in the original object:
    if r := e.enum.Next(i,k)
        ; We want it to appear as though the user is simply enumerating
        ; the key-value pairs of the original object, so store the value
        ; associated with this key in the second output variable:
        v := e.obj[k]
    return r
}

oaRemove(obj, prm*)
{
    r := ObjRemove(obj, prm*)         ; Remove keys from main object
    Removed := []                     
    for k, v in obj._keys             ; Get each index key pair
        if not ObjHasKey(obj, v)      ; if key is not in main object
            Removed.Insert(k)         ; Store that keys index to be removed later
    for k, v in Removed               ; For each key to be removed
        ObjRemove(obj._keys, v, "")   ; remove that key from key list
    return r
}

oaInsert(obj, prm*)
{
    r := ObjInsert(obj, prm*)            ; Insert keys into main object
    enum := ObjNewEnum(obj)              ; Can't use for-loop because it would invoke oaNewEnum
    while enum[k] {                      ; For each key in main object
        if (k = "_keys")
            continue 
        for i, kv in obj._keys           ; Search for key in obj._keys
            if (k = kv)                  ; If found...
                continue 2               ; Get next key in main object
        ObjInsert(obj._keys, k)          ; Else insert key into obj._keys
    }
    return r
}

oaInsertBefore(obj, key, prm*)
{
    OldKeys := obj._keys                 ; Save key list
    obj._keys := []                      ; Clear key list
    for idx, k in OldKeys {              ; Put the keys before key
        if (k = key)                     ; back into key list
            break
        obj._keys.Insert(k)
    }
    
    r := ObjInsert(obj, prm*)            ; Insert keys into main object
    enum := ObjNewEnum(obj)              ; Can't use for-loop because it would invoke oaNewEnum
    while enum[k] {                      ; For each key in main object
        if (k = "_keys")
            continue 
        for i, kv in OldKeys             ; Search for key in OldKeys
            if (k = kv)                  ; If found...
                continue 2               ; Get next key in main object
        ObjInsert(obj._keys, k)          ; Else insert key into obj._keys
    }
    
    for i, k in OldKeys {                ; Put the keys after key
        if (i < idx)                     ; back into key list
            continue
        obj._keys.Insert(k)
    }
    return r
}

Example Code:

Spoiler

#Include <OrderedArray>

; Autoexecute
	#NoEnv
	#SingleInstance force
	
	Array := Object("ten", 10, "twenty", 20, "thirty", 30)
    For Key, Value in Array
        MsgBox %Key%, %Value%
    
    Array := OrderedArray("ten", 10, "twenty", 20, "thirty", 30)
    For Key, Value in Array
        MsgBox %Key%, %Value%
    
    Array := Object()
    Array["a", "one"] := 1
    Array["a", "two"] := 2
    Array["a", "three"] := 3
    Array["a", "four"] := 4
    
    for k, v in Array.a
        t .= k " = " v "`n"
    MsgBox % t

    t := ""
    Array := OrderedArray()
    Array["a", "one"] := 1
    Array["a", "two"] := 2
    Array["a", "three"] := 3
    Array["a", "four"] := 4
    
    for k, v in Array.a
        t .= k " = " v "`n"
    MsgBox % t

return

Example of InsertBefore()

Spoiler

#Include <OrderedArray>

; Autoexecute
	#NoEnv
	#SingleInstance force
	
    Array := OrderedArray("jan", 1, "feb", 2, "mar", 3, "may", 5, "jun", 6, "aug", 8, "sept", 9, "oct", 10, "nov", 11, "dec", 12)
    
    t := ""
    for k, v in Array
        t .= k " = " v "`n"
    MsgBox % t

    Array.InsertBefore("aug", "jul", 7)
    Array.InsertBefore("may", "apr", 4)
    
    t := ""
    for k, v in Array
        t .= k " = " v "`n"
    MsgBox % t

    Array.InsertBefore("sept", 5, "one", "Two")
    t := ""
    for k, v in Array
        t .= k " = " v "`n"
    MsgBox % t
    
return

Edited by rbrtryn, 19 August 2013 - 01:32 AM.

[ahkkha]

Thanks for this great job. AHK should have native support for it.

[rbrtryn]

New feature: Added an InsertBefore() method, which allows items to be inserted at a specific location in the array. Added an example of how this works in the OP.

[Moebius]

There is a problem, if an alphanumeric key is used with Insert():

afp := OrderedArray()
afp.Insert("a","fdsfsf")
for k,v in afp 
msgbox %k% -- %v%

returns 2 items:

_keys

a -- fdsfsf

[rbrtryn]

There is a problem, if an alphanumeric key is used with Insert():
returns 2 items:
_keys
a -- fdsfsf

Thanks for reporting that. It should be fixed now. Try the new version and let me know if the are any further problems.

[Moebius]

Thanks for the quick response.

Meanwhile another problem occured:

 

I use the array to store window handles of controls. The key is the hwnd (hex) and after the first item, an insert generates more than one entry.

afp := OrderedArray()
afp.Insert(0x7880696,"fdsfsf")
afp.Insert(0x62d14f8,"vcvcxv")
afp.Insert(0x1900c60,"xcvcx")
for k,v in afp 
msgbox %k% -- %v%

Result:

126355094--
103617784--
126355095--
26217568--xcvcx
103617785--vcvcxv
126355096--fdsfsf
 

The logic looks like this:

1. ok

2. + 1 item with key - 1

3. + 2 items with key -2 and -1

[rbrtryn]

I use the array to store window handles of controls. The key is the hwnd (hex) and after the first item, an insert generates more than one entry.

This is caused by the way AutoHotkey internally handles the Insert() method. For integer keys, Insert() will automatically increment any integer keys greater than one you are inserting. An example with a standard array:

afp := []
afp.Insert(0x7880696,"fdsfsf")
afp.Insert(0x62d14f8,"vcvcxv")
afp.Insert(0x1900c60,"xcvcx")
for k,v in afp 
msgbox %k% -- %v%
return

The solution is don't use Insert():

afp := OrderedArray()
afp[0x7880696] := "fdsfsf"
afp[0x62d14f8] := "vcvcxv"
afp[0x1900c60] := "xcvcx"
for k,v in afp 
msgbox %k% -- %v%

The doubled output of keys you are seeing is because my oaInsert() method has no way of knowing which keys were incremented and which were not, so the _keys array includes both versions.

[Verdlin]

Just to be clear, is the following the same as the issue that Moebius had?

{
#Include <OrderedArray>

	t := ""
	Array := OrderedArray()
	Array[4, "four"] := 1
	Array[3, "three"] := 2
	Array[1, "one"] := 3
	Array[2, "two"] := 4

	for sec, aData in Array
		for k, v in aData
			t .= k " = " v "`n"
	MsgBox % t

	return
}

Output:

---------------------------
AutoHotkey.ahk
---------------------------
three = 3
four = 4

---------------------------
OK   
---------------------------
 

[Larctic]

Will the availability of V2 version?

[SnowFlake_FlowSnake]

Will the availability of V2 version?

1+ for that