[script] Collections

//! zinc
/*
    Collections implements an arraylist. An Arraylist is a resizable array.
    if you are unsure of the amount of instances you might be storing,
    and would like something portable and type-safe then you can use this class.
    It wraps a hashtable.
    Requires:: JassHelper 0.A.2.7 by Vexorian.
    
    Instantiation::
    --------------
    //! runtextmacro ListTemplate("T","TypeName","BaseName","DefaultVal")
    T -- the T that stored in this collection.
    
    TypeName -- The name of the type used in Save/Load HashTable natives.
    e.g. Integer,Real,Boolean,String,ItemHandle,UnitHandle etc.
    
    BaseName -- the name of the type used in Have/Remove Hashtable natives.
    e.g. Integer,Real,Boolean,Str,Handle
    
    DefaultVal -- The default value of the type.
    e.g. 0,0.0,false,null
    
    Supported Types::
    ----------------
    Integer,Real,Boolean,String,almost all Handle types, and any user type.
    
    use examples::
    //! runtextmacro ListTemplate("item","ItemHandle","Handle","null")
    //! runtextmacro ListTemplate("ItemMenu","Integer","Integer","0")


    New Types::
    -----------
    List_T arraylist of Ts.
    Action_T a function that takes a T.
    
    
    
    List_$T$ method index
    Operators::
    -----------
    Get/Set [index integer]->T -- get or set the element* at index
    NOTE: Does bound checking. Only allowed to store values in 0-Size-1.
    
    List of Properties::
    -------------------
    Getters::
    Size->integer -- gets the total number of elements stored in this collection.
    
    Capacity->integer -- get the max number of elements storable in this instance.
    
    Setters::
    Capacity(integer value) -- sets the max number of elements storable in this instance.
    
    Methods::
    --------
    Add(T value)->boolean -- adds a value to the end of the collections. Returns false on failure.
    
    RemoveAt(integer index)->T -- removes the element located at index and left shifts to fill the whole.
    e.g. if the collection is 1,2,3,4,5 and you remove element 3, then it'll shift to be 1,2,4,5
    
    UnstableRemoveAt(integer index)->T -- removes the element at index. But shifts the last element to fill the hole.
    e.g. if the collection is 1,2,3,4,5 and you remove element 3, then it'll be 1,2,5,4. Obviously only useful if you
    don't care at all about order.
    
    IndexOf(T value)->integer -- returns the first index of a value in the list. Returns -1 if it finds nothing.
    
    Contains(T value)-> boolean -- returns if this list has value in it.
    
    Remove(T value) -> boolean -- removes the first location of value in the collection. And left shifts accordingly.
    returns if it did remove.
    
    Clear() -- removes all elements in this collection. Retains capacity information.
    
    
    ForEach(Action_T func) -- applies func to each member of the collection.
    e.g.
    List_integer ints = List_integer.create(0);
    ints.Add(1);ints.Add(2);ints.Add(3);
    ints.ForEach(function(integer x){BJDebugMsg(I2S(x));} // prints 1/n2/n3/n
    
    Clone()-> List_T -- returns a 
    
    Constructors::
    -------------
    .create(integer capacity)->List_T returns a List_T of capacity capacity.
    
    * Note due to a bug hashtables can't store null so I'm forced to remove the element
        when you try to use the default value
*/
library Collections
{
//! textmacro ListTemplate takes T,typename,baseName,DefaultVal
    type Action_$T$ extends function($T$);
    public struct List_$T$
    {
        private integer m_Size;
        private integer m_Capacity;
        private static hashtable Table = InitHashtable();
        method operator Size()->integer
        {
            return m_Size;
        }
        method operator Capacity()->integer
        {
            return m_Capacity;
        }
        method operator Capacity=(integer value)
        {
            m_Capacity = value;
        }
        
        method operator[](integer index)->$T$
        {
            $T$ retVal = $DefaultVal$;
            if( - 1 < index && index < m_Size)
            {
                retVal = Load$typename$(Table,integer(this),index);
            }
            return retVal;
        }
        method operator[]=(integer index,$T$ value)
        {
            if( -1 < index && index < m_Size)
            {
                // Storing null doesn't actually do anything. It won't override values. So we have to remove things in that case.
                // Since staticif  currently does not support reading parameters from macros this is all that can be done.
                if(value == $DefaultVal$) RemoveSaved$baseName$(Table,integer(this),index);
                else Save$typename$(Table,integer(this),index,value);
            }
        }
        method Add($T$ obj)->boolean
        {
            boolean retVal = false;
            if(m_Capacity == 0 || m_Size < m_Capacity)
            {
                m_Size+=1;
                this[m_Size-1]= obj;
                retVal = true;
            }
            return retVal;
        }
        
        method RemoveAt(integer index)->$T$
        {
            $T$ retVal = $DefaultVal$;
            integer i;
            if(-1 < index && index < m_Size)
            {
                retVal = this[index];
                for(i = index; i < m_Size-1; i+=1)
                {
                    this[i] = this[i+1];
                }
                m_Size-=1;
                RemoveSaved$baseName$(Table,integer(this),m_Size);
            }
            return retVal;
        }
        // Performs at O(1) time, but moves things about
        // in the process.
        method UnStableRemoveAt(integer index)-> $T$ 
        {
            $T$ retVal = $DefaultVal$;
            if( - 1 < index && index < m_Size)
            {
                retVal = this[index];
                this[index] = this[m_Size-1];
                m_Size-=1;
                RemoveSaved$baseName$(Table,integer(this),m_Size);
            }
            return retVal;
        }
        
        method IndexOf($T$ value)->integer
        {
            integer i = 0;
            integer retVal = -1;
            for(i = 0; i < m_Size; i+=1)
            {
                if(this[i] == value)
                {
                    retVal = i;
                    break;
                }
            }
            return retVal;
        }
        
        method Contains($T$ value)->boolean
        {
            return IndexOf(value) > -1;
        }
        
        method Remove($T$ value)->boolean
        {
            integer index = IndexOf(value);
            if(index > -1) RemoveAt(index);
            return (index > -1);
        }
        
        method Clear()
        {
            FlushChildHashtable(Table,integer(this));
            m_Size = 0;
        }
        
        method ForEach(Action_$T$ func)
        {
            integer i;
            for(i = 0;i < m_Size; i+=1)
            {
                func.evaluate(this[i]);
            }
        }
        private method onDestroy()
        {
            Clear();
        }
        
        // This is a shallow clone
        static method Clone(thistype list)->thistype
        {
            thistype retVal = thistype.create(list.m_Capacity);
            integer i;
            for(i = 0; i < list.m_Size; i+=1)
            {
                retVal.Add(list[i]);
            }
            return retVal;
        }
        
        // Yes, I suppose I could've wrote List(T) but hey thistype sweet!
        // passing 0 creates a list without a fixed cap.
        static method create(integer capacity)->thistype
        {
            thistype retVal = thistype.allocate();
            retVal.m_Capacity = capacity;
            return retVal;
        }
    }
//! endtextmacro
}
//! endzinc

SaveUnitHandle(tablevar,0,0,CreateUnit(Player(0),'hfoo',0,0,0));
SaveUnitHandle(tablevar,0,0,null);
BJDebugMsg(I2S(GetHandleId(LoadUnitHandle(tablevar,0,0)))