Snippet CSA - Custom Struct Allocator

[kingkingyyk3]

SSA - Safety Struct Allocator

//////////////////////////////////
//    ____   ____   
//   /  __| / ___|  /\     SAFETY STRUCT ALLOCATOR v1.0.1
//   \ \    \ \    /__\       by kingking
//   _\ \   _\ \  / || \
//  |___/  |___/ /_|  |_\
//
//  What is SSA?
//  It is a safety struct allocator.
//
//  Why use this?
//  This is safer than default struct allocator.
//
//  Who should use this?
//  Who want safety first.
//
//  When to use this?
//  Anywhere you like. =D
//
//  How to use this?
//  Put "implement CSA" in your struct.
//  Replace vars.onDestroy with vars.customDestroy
//  Replace struct.allocate with struct.get
//  Replace vars.destroy with vars.release
//  CSA featured structs must extends array for safety issues.
//
//  Features :
//  Recycle indexes
//  Double-free protection
//
//  Testing(If you want) :
//  Run in debug mode.
//  Release 2 same struct index. You can see error report.
//
//  Requirements :
//  Jasshelper (As new as possible)
///////////////////////////////////
library SafetyStructAllocator
    
   public struct METHODS extends array
        method customDestroy takes nothing returns nothing
        endmethod
    endstruct
    
endlibrary

    module SSA
        private static delegate SafetyStructAllocator_METHODS FUNCTIONS=0
        private static boolean array CSA_instantiated
        private static thistype array CSA_removedInstances
        private static integer CSA_removedCount = 0
        private static integer CSA_counter = 0
        private static integer CSA_this
        
        static method get takes nothing returns thistype
            if thistype.CSA_removedCount == 0 then
                set thistype.CSA_this = thistype.CSA_removedInstances[thistype.CSA_removedCount]
                set thistype.CSA_instantiated[thistype.CSA_this] = true
                set thistype.CSA_removedCount = thistype.CSA_removedCount - 1
                return thistype.CSA_this
            endif
            set thistype.CSA_counter = thistype.CSA_counter + 1
            return thistype.CSA_counter
        endmethod
        
        method release takes nothing returns nothing
            if thistype.CSA_instantiated[this] then
                call this.customDestroy()
                set thistype.CSA_instantiated[this] = false
                set thistype.CSA_removedCount = thistype.CSA_removedCount + 1
                set thistype.CSA_removedInstances[thistype.CSA_removedCount] = this
            debug else
                debug call BJDebugMsg("Double Free founded on #" + I2S(this) "!")
            endif
        endmethod
    endmodule

:thup:

 

[lep]

Ehrm, that "speed" means the time passed between the two marks. Less time means faster computation.

Correct me if i'm wrong...

 

[aliminator8]

Ehrm, that "speed" means the time passed between the two marks. Less time means faster computation.

Correct me if i'm wrong...

he has a good point....

 

[kingkingyyk3]

Yea, I was dreaming when creating this thing.

It is for safety but not for speed. Sorry for posting wrong infomation.
Changed the name to -> SSA (Safety Struct Allocator)

 

[lep]

How is this "safer"?

It let you have more than 8191 instances. It uses more memory. It uses some hackish things like delegating on array-structs for some reasons. It probably gets fucked up when using oversized structs.

Realy, i don't see any benefit of using this.

 

[Vestras]

AFAIK JassHelper struct allocating does the same as yours.

 

[Uberplayer]

My only comment for this is about the header. When will you guys stop using Ascii art for your scripts?

 

[Romek]

> When will you guys stop using Ascii art for your scripts?
UAC was first!
My ASCII art looks somewhat decent though.

………………..,-~*’`¯lllllll`*~,
…………..,-~*`lllllllllllllllllllllllllll…
………,-~*lllllllllllllllllllllllllllllll…
……,-*lllllllllllllllllllllllllllllllll…
….;*`lllllllllllllllllllllllllll,-~*~-…
…..\lllllllllllllllllllllllllll/………\;;…
…...\lllllllllllllllllllll,-*………..`~-~…
…….\llllllllllll,-~*…………………)_-\..*`*;.…
……..\,-*`¯,*`)…………,-~*`~.………….../
……...|/.../…/~,…...-~*,-~*`;……………./.\
……../.../…/…/..,-,..*~,.`*~*…………….*...…
…….|.../…/…/.*`...\...……………………)….)¯`~,
…….|./…/…./…….)……,.)`*~-,……….../….|..)…
……/./.../…,*`-,…..`-,…*`….,---…...\…./…
…...(……….)`*~-,….`*`.,-~*.,-*……|…/.…/……
…….*-,…….`*-,...`~,..``.,,,-*……….|.,*.…
……….*,………`-,…)-,…………..,-*`...,-*….(`-
Anyway, how is this any safer than the default struct allocating?
Do note that, that also has double-free protection.

 

[Azlier]

Jasshelper's allocator is safer than this. You have accomplished nothing.

Well done! It's hard to accomplish less than nothing.

 

[Romek]

Hmm.. Graveyarded. There's no point in this even being here.
Your resources are becoming somewhat of a joke.

If you're going to claim something is faster, let alone safer, at least do a test to be able to compare it to something else.
A simple:

local Data d = Data.create()
call d.destroy()
call d.destroy()

Would've proven to you that the default deallocator does protect against double frees.

As well as this having no purpose whatsoever, the interface simply sucks, and nobody in their right mind would use something like this over the default allocator.