Ordered Associative Array

[Capn Odin]

I am sure this already exists on the forum.
Source

---

Code: Select all

Class OrderedAssociativeArray {
	__New() {
		ObjRawSet(this, "__Data", {})
		ObjRawSet(this, "__Order", [])
	}
	
	__Get(args*) {
		return this.__Data[args*]
	}
	
	__Set(args*) {
		key := args[1]
		val := args.Pop()
		if(args.Length() < 2 && this.__Data.HasKey(key)) {
			this.Delete(key)
		}
		if(!this.__Data.HasKey(key)) {
			this.__Order.Push(key)
		}
		this.__Data[args*] := val
		return val
	}
	
	InsertAt(pos, key, val) {
		this.__Order.InsertAt(pos, key)
		this.__Data[key] := val
	}
	
	RemoveAt(pos) {
		val := this.__Data[this.__Order[pos]]
		this.__Data.Delete(this.__Order[pos])
		this.__Order.RemoveAt(pos)
		return val
	}
	
	Delete(key) {
		for i, v in this.__Order {
			if(key == v) {
				return this.RemoveAt(i)
			}
		}
	}
	
	Length() {
		return this.__Order.Length()
	}
	
	HasKey(key) {
		return this.__Data.HasKey(key)
	}
	
	_NewEnum() {
		return new OrderedAssociativeArray.Enum(this.__Data, this.__Order)
	}
	
	Class Enum {
		__New(Data, Order) {
			this.Data := Data
			this.oEnum := Order._NewEnum()
		}
		
		Next(ByRef key, ByRef val := "") {
			res := this.oEnum.next(, key)
			val := this.Data[key]
			return res
		}
	}
}

Test

---

Code: Select all

#include OrderedAssociativeArray.ahk
lst := new OrderedAssociativeArray()

lst["x"] := 14
lst["a"] := 1
lst["h"] := 15

test(lst)
lst.Delete("a")
test(lst)
lst.InsertAt(1, "w", 3535)
test(lst)
lst.RemoveAt(2)
test(lst)

test(obj) {
	res := ""
	for i, v in obj {
		res .= i " = " v "`n"
	}
	MsgBox, % res
}

[Guest]

Really needed this.
Thanks for sharing

[joedf]

Interesting...
somehow related?
https://autohotkey.com/boards/viewtopic.php?f=6&t=3790

[wolf_II]

@Capn Odin: Thanks for sharing!

I have problems wrapping my head around Next and _NewEnum. Would you mind posting an example use of these? I guess more people other than myself will benefit from those examples.
Maybe you can also offer a sentence or two of explanation, please? Like, why not return this.__Data ?

[jeeswg]

Cheers for this. I'll point out some similar code I was working on.

[4 types of array: CSA CSD CIA CID (case (in)sensitive, keys returned in alphabetical/creation date order)]
[not classes as such, but the same principles used to create stand-alone functions]
text/list/table functions - AutoHotkey Community
https://autohotkey.com/boards/viewtopic ... 85#p151285
[preliminary (mostly complete) work for classes:]
case sensitive/case insensitive arrays (maintain key order, no key autosort) - AutoHotkey Community
https://autohotkey.com/boards/viewtopic.php?f=5&t=29198
objects: ordered array (function syntax to method syntax) - AutoHotkey Community
https://autohotkey.com/boards/viewtopic.php?f=5&t=31472

[Helgef]

Hello, thanks for sharing, nice one
Minor comments, you can add __new() and use objrawset for __data and __order to avoid having the ifs in __get and __set. Eg,

Code: Select all

__new(){
	objrawset(this,"__Data",[])
	objrawset(this,"__Order",[])
}

You should adjust your next method, because, "" is a valid key name, and will cause a pretty boring loop
Interesting with insertAt and removeAt methods.

: Did you have any own interest in using something like this or did you want to do some coding?

---

@ wolf_II, hi _newEnum is (edit: mostly used) for for loops. If __data is returned the for loop will visit the keys in alphabetical order, not in the order in __order.
Cheers.

[Capn Odin]

Added support for nested loops.

Thank you for the suggestions.

I will explain it after I have had lunch and taken my medication.

[arcticir]

Does it not automatically create an object?
lst["x",3] := 14
lst["x",1] := 14

[Capn Odin]

Does it not automatically create an object?
lst["x",3] := 14
lst["x",1] := 14

Oh, that's right, I had forgotten about this behavior.

[jeeswg]

Btw, does anyone know if it's possible to have multiple Enum/Next methods, and to include a method that will set which Enum is used? Thanks.

[Helgef]

Ofc jeeswg, newenum can return any object with a next method.

[Capn Odin]

Changed to use an enum class instead of keeping track of enumeration in the instance itself, this was to add support for empty keys.

[Capn Odin]

: Did you have any own interest in using something like this or did you want to do some coding?

I have definitely needed the functionality this class provides before, but I never felt that making two objects was too much of a hassle. The thing I find most interesting about making this class is to make it feel like a native object.

I have problems wrapping my head around Next and _NewEnum.

Both _NewEnum and Next are used by for loops.
The for loop calls _NewEnum once at the start, it then in order to get the keys and values, in each iteration calls Next on the object returned by _NewEnum. Next is called until it returns False.

Maybe you can also offer a sentence or two of explanation, please? Like, why not return this.__Data ?

The reason for having _NewEnum return something other then __Data is like Helgef said to control the sequence in which the keys and values are feed to the for-loop.

[Capn Odin]

Does it not automatically create an object?
lst["x",3] := 14
lst["x",1] := 14

It should work now.

[arcticir]

I tested its performance. Compared to the same effect of "OrderedArray ()",It is very slow..

[Capn Odin]

I tested its performance. Compared to the same effect of "OrderedArray ()",It is very slow..

I would love to know what you tested, it will make it easier to figure out where to make improvements.
Were you testing Creating objects, Retrieving values, Adding values, Removing values or Enumeration ?

[arcticir]

Simple "FOR"

[Helgef]

Maybe try this,

Code: Select all

Class Enum {
	__New(Data, Order) {
		this.Data := Data
		this.orderEnum := Order._NewEnum()
	}
	Next(ByRef key, ByRef val := "") {
		local r, k
		r:=this.orderEnum.next(k,key)
		val:=this.Data[key]
		return r
	}
}

[Capn Odin]

Maybe try this,

Code: Select all

Class Enum {
	__New(Data, Order) {
		this.Data := Data
		this.orderEnum := Order._NewEnum()
	}
	Next(ByRef key, ByRef val := "") {
		local r, k
		r:=this.orderEnum.next(k,key)
		val:=this.Data[key]
		return r
	}
}

Yeah, I came to a similar solution based on this thread linked by jeeswg https://autohotkey.com/boards/viewtopic.php?f=5&t=31472

Code: Select all

Class Enum {
	__New(Data, Order) {
		this.Data := Data
		this.oEnum := Order._NewEnum()
	}
	
	Next(ByRef key, ByRef val := "") {
		res := this.oEnum.next(, key)
		val := this.Data[key]
		return res
	}
}

By the way what do the keyword local do ?

Edit: I made this as my first attempt at optimising it. Do you know why it is slower then the above ?

Code: Select all

Class Enum {
	i := 1
	__New(Data, Order) {
		this.Data := Data
		this.Order := Order
		this.Len := Order.Length() + 1
	}
	
	Next(ByRef key, ByRef val := "") {
		val := this.Data[key := this.Order[this.i]]
		return this.i++ <= this.Len
	}
}

[Helgef]

Regarding local, it is for avoiding overwritning super-global variables. Ofc, in the examples here there are no such variables, but I put it there due to new habits.
Regarding performance differences, the main differance is probably due to using the built-in enumObject, for loops are in general faster than normal loops when it comes to objects, if irc. I guess it comes down to implementation details, which I know nothing about.
I didn't make any benchmarks, were the differences big between the first version and using the built-in enumerator for the order array?
Maybe a one-liner is even faster: return this.oEnum.next(, key) ? (val := this.Data[key], true) : false.
Finally, maybe you should use the objXXX() functions instead of the corresponding methods, like objHasKey() instead of .hasKey(). As it is now, lst["hasKey"] :=... breaks the script. The functions might be a bit faster too.
Anyways, I think it has turned out very nice and I will refer to it when needed, cheers.