System GroupTools

[Dirac]

Well in some tests i ran (running ForGroup 500 times for the same group every 0.03125 seconds or 500 groups called ForGroup every 0.03125 seconds) it didn't leak at all.

 

[luorax]

It only leaks if the group is destroyed immediately after the ForGroup call. But it doesn't matter if you use GroupUtils (or something similar, for example I'm using my own GroupTools, which is a GroupUtils remake), as with GroupUtils, groups are never destroyed.

 

[Jedi]

It only leaks if the group is destroyed immediately after the ForGroup call.

Sorry no offense but that makes no sense, proof?

 

[Dirac]

The benchmark i used on tooltiperror's system is broken, its actually equally or slower than my system because it has a flaw:

When using enumerator all units from the group are removed, therefore after the first loop no more units are enumerated, therefore the benchmark didn't return correct results.

After running some benchmarks on this system i realized something:

-Its as same as fast as the ForGroup native
-Its WAY faster than the FirstOfGroup native
-Can't implement common ForGroup call for this system, would kill all the speed it provides. This system WORKS if you intend to access units from a loop from within the function like this

        static UnitGroup G
        private static method period takes nothing returns nothing
            local integer i=5
            local integer n=0
            local unit u
            loop
                exitwhen 0==i
                loop
                    exitwhen n==G.count
                    set u=G.NextOfGroup
                    call DisplayTimedTextToPlayer(Player(0),0,0,60,(I2S(GetRandomInt(1,100))+" - "+GetUnitName(u)))
                    set n=n+1
                endloop
                set n=0
                set i=i-1
            endloop
            set u=null
        endmethod

The [ljass]DisplayTimedTextToPlayer[/ljass] native leaks lol

 

[Solmyr]

The [ljass]DisplayTimedTextToPlayer[/ljass] native leaks lol

No, newly created strings leak, not the function per se.

>use common ForGroup calls
Leaks.

You've no idea what you're talking about.

 

[tooltiperror]

>You've no idea what you're talking about.
Generally it is considered improper to post responses like these, because they are usually over small misunderstandings and make you look like a douchebag. You seem to post a lot of responses such as these where you blatantly call people out in a rude way, and at The Helper we frankly do not encourage posts like this.

However, what I said was indeed false, I should have said that processes involving [LJASS]ForGroup[/LJASS] generally tend to end up leaking, and it can be solved with a filter instead.

 

[Dirac]

I'm getting this new idea, a module you implement into your struct that turns it into a GroupStruct. These structs have a "enumeration method" that takes unit u and runs itself for every unit inside the group when calling runGroup.

The way i see it there are 2 ways to develop it:

-Static group: the struct will only handle 1 group at the time, the library would require AIDS or UnitIndexer
-Multi Instanceable groups: the struct can be allocated for many groups, the library would require Table

 

[Dirac]

Ok since the data i've been getting from benchmarks on native groups and array groups are basically the same (only 2 fps drop from these kind of groups) I've decided that this system deserves an oportunity.

Update.
-Added the SimpleGroup struct
-Removed the forGroup method (which was very slow anyways) along with the forGroup tools

 

[Laiev]

[ljass]method operator FirstOfGroup takes nothing returns unit[/ljass]
>
[ljass]method operator firstOfGroup takes nothing returns unit[/ljass]