[INC]ArrayList - dynamic arrays

#define INVALID_ARRAYLIST_ID            ArrayList:-1

static Alloc:gListMemory = NO_ALLOC;


/**
    <summary>NewArrayList</summary>
    <returns>Naujo ArrayList ID arba INVALID_ARRAYLIST_ID nepavyksu jo sukurti</returns>
*/
stock ArrayList:NewArrayList()
{
    new size = 0;

    if(gListMemory != NO_ALLOC)
        size = Malloc_SlotSize(gListMemory);

    size++;

    new Alloc:tmp = malloc(size);
    if(tmp == NO_ALLOC)
    {
        printf("Error. Failed allocating memory.");
        return INVALID_ARRAYLIST_ID;
    }
    for(new i = 0; i < size-1; i++)
    {
        mset(tmp, i, mget(gListMemory, i));
    }
    if(gListMemory != NO_ALLOC)
        free(gListMemory);

    gListMemory = tmp;

    mset(gListMemory, size-1, 0);
    return ArrayList:(size-1);
}


/**
    <summary>ArrayListAdd</summary>
    <param name="ArrayList:id">ArrayList ID į kurį bus pridėta vertė</param>
    <param name="value">vertė kuri bus pridėta</param>
    <returns>Įrašytos vertės indeksą arba -1 nepavykus įrašyti</returns>
*/
stock ArrayListAdd(ArrayList:id, value)
{
    if(!IsValidArrayList(id))
        return -1;
    new Alloc:array = Alloc:mget(gListMemory, id),
        size = 0;
    if(array != NO_ALLOC)
        size = Malloc_SlotSize(array);

    size++;
    new Alloc:tmp = malloc(size);
    if(tmp == NO_ALLOC)
    {
        printf("Error. Failed allocating memory.");
        return -1;
    }

    for(new i = 0; i < size-1; i++)
        mset(tmp, i, mget(array, i));

    if(array != NO_ALLOC)
        free(array);

    mset(tmp, size-1, value);
    mset(gListMemory, id, _:tmp);
    return size-1;
}
/**
    <summary>ArrayListAddS</summary>
    <param name="ArrayList:id">ArrayList ID į kurį bus pridėta vertė</param>
    <param name="value[]">String vertė kuri bus pridėta</param>
    <returns>Įrašyto string pradžios indeksą arba -1 nepavykus įrašyti</returns>
*/
stock ArrayListAddS(ArrayList:id, value[])
{
    if(!IsValidArrayList(id))
        return -1;

    new Alloc:array = Alloc:mget(gListMemory, id),
        index = Malloc_SlotSize(array);

    new size = index + strlen(value) + 1;
    new Alloc:tmp = malloc(size);
    if(tmp == NO_ALLOC)
    {
        print("Error. Failed allocating memory.");
        return -1;
    }

    for(new i = 0; i < index; i++)
        mset(tmp, i, mget(array, i));
    if(array != NO_ALLOC)
        free(array);

    msets(tmp, index, value);
    mset(gListMemory, id, _:tmp);
    return index;
}

/**
    <summary>ArrayListAddA</summary>
    <param name="ArrayList:id">ArrayList ID į kurį bus pridėta vertė</param>
    <param name="value[]">Masyvas kuris bus pridėtas</param>
    <param name="len">Elementų skaičius masyve kuriuos reikia pridėti</param>
<returns>true sėkmingai pridėjus</returns>
*/
stock ArrayListAddA(ArrayList:id, array[], len)
{
    for(new i = 0; i < len; i++)
        ArrayListAdd(id, array[ i ]);
    return true;
}

/**
    <summary>ArrayListRemove</summary>
    <param name="ArrayList:id">ArrayList ID iš kurio bus pašalinta vertė</param>
    <param name="value">Vertė kuri bus pridėta</param>
    <returns>true sėkmingai pašalinus, false kitais atvejais</returns>

    <remarks>Pawn String yra skaičiai, todėl gali dingti raidės. Pvz: pašalinus iš masyvo 65 gali būti pašalinta 'A' raidė</remarks>
*/
stock ArrayListRemove(ArrayList:id, value)
{
    if(!IsValidArrayList(id))
        return false;
    if(ArrayListIndexOf(id, value) == -1)
        return false;

    new Alloc:list = Alloc:mget(gListMemory, id);
    if(list == NO_ALLOC)
        return false;

    for(new i = 0; i < Malloc_SlotSize(list); i++)
    {
        if(mget(list, i) == value)
        {
            new Alloc:tmp = malloc(Malloc_SlotSize(list)-1);
            if(tmp == NO_ALLOC)
            {
                print("Error. ArrayListRemove : Failed allocating memory.");
                free(tmp);
                return false;
            }
            for(new j = 0; j < i; j++)
                mset(tmp, j, mget(list, j));

            for(new j = i+1; j < Malloc_SlotSize(list); j++)
                mset(tmp, j-1, mget(list, j));

            free(list);
            mset(gListMemory, id, tmp);
            return true;
        }
    }
    return false;
}

/**
    <summary>ArrayListRemoveAtIndex</summary>
    <param name="ArrayList:id">ArrayList ID iš kurio bus pašalinta vertė</param>
    <param name="index">Vertės indeksas</param>
    <returns>true sėkmingai pašalinus, false kitais atvejais</returns>
*/
stock ArrayListRemoveAtIndex(ArrayList:id, index)
{
    if(!IsValidArrayList(id))
        return false;
    if(!IsValidArrayListIndex(id, index))
        return false;

    new Alloc:list = Alloc:mget(gListMemory, id),
        Alloc:tmp = malloc(Malloc_SlotSize(list)-1);
    if(list == NO_ALLOC)
        return false;

    new count = 0;
    for(new i = 0; i < Malloc_SlotSize(list); i++)
    {
        if(i == index)
            continue;
        mset(tmp, count++, mget(list, i));
    }
    free(list);
    mset(gListMemory, id, tmp);
    return true;
}

/**
    <summary>ArrayListGet</summary>
    <param name="ArrayList:id">ArrayList ID iš kurio gauta vertė</param>
    <param name="index">Indeksas iš kurio bus gauta vertė</param>
    <returns>Vertę esančią indekse, 0 - jei tos vertės nėra</returns>
*/
stock ArrayListGet(ArrayList:id, index)
{
    if(!IsValidArrayList(id))
        return 0;
    new Alloc:tmp = Alloc:mget(gListMemory, id);
    if(!IsValidArrayListIndex(id, index))
        return 0;
    return mget(tmp, index);
}


/**
    <summary>ArrayListGetS</summary>
    <param name="ArrayList:id">ArrayList ID iš kurio bus gautas string</param>
    <param name="index">String pradžios indeksas</param>
    <param name="dest[]">Masyvas į kurį bus įrašytas string</param>
    <param name="len">Masyvo dydis</param>
    <returns> - </returns>
*/
stock ArrayListGetS(ArrayList:id, index, dest[], len)
{
    if(!IsValidArrayList(id))
        return;
    if(!IsValidArrayListIndex(id, index))
        return;
    mgets(dest, len, Alloc:mget(gListMemory, id), index);
}

/**
    <summary>ArrayListSet</summary>
    <param name="ArrayList:id">ArrayList ID kuriame bus pakeista vertė</param>
    <param name="index">Vertės indeksas</param>
    <param name="value">Nauja vertė</param>
    <returns> true - sėkmingai pakeitus vertė, false kitais atvejais</returns>
*/
stock ArrayListSet(ArrayList:id, index, value)
{
    if(!IsValidArrayList(id))
        return false;
    if(!IsValidArrayListIndex(id, index))
        return false;

    new Alloc:list = Alloc:mget(gListMemory, id);
    if(list == NO_ALLOC)
        return false;

    mset(list, index, value);
    return true;
}


/**
    <summary>ArrayListClear</summary>
    <param name="ArrayList:id">ArrayList ID kuris bus ištuštintas</param>
    <returns> true - sėkmingai ištuštinus ArrayList, false kitais atvejais</returns>

    <remarks>Ši funkcija nesunaikina ArrayList, ji tik ištuština jo turinį</remarks>
*/
stock ArrayListClear(ArrayList:id)
{
    if(!IsValidArrayList(id))
        return false;

    new Alloc:list = mget(gListMemory, _:id);
    if(list == NO_ALLOC)
        return false;
    free(list);
    return true;
}



/**
    <summary>ArrayListIndexOf</summary>
    <param name="ArrayList:id">ArrayList ID kuriame bus ieškoma vertės</param>
    <param name="value">Vertė kurios bus ieškoma</param>
    <returns>Vertės indeksą, -1 jos neradus</returns>
*/
stock ArrayListIndexOf(ArrayList:id, value)
{
    if(!IsValidArrayList(id))
        return -1;

    new Alloc:tmp = Alloc:mget(gListMemory, id);
    if(tmp == NO_ALLOC)
        return -1;

    for(new i = 0; i < Malloc_SlotSize(tmp); i++)
        if(mget(tmp, i) == value)
            return i;
    return -1;
}



/**
    <summary>ArrayListSize</summary>
    <param name="ArrayList:id">ArrayList ID</param>
    <returns>ArrayList dydį</returns>
*/
stock ArrayListSize(ArrayList:id)
{
    if(!IsValidArrayList(id))
        return 0;
    return Malloc_SlotSize(Alloc:mget(gListMemory, id));
}


/**
    <summary>ArrayListIsEmpty</summary>
    <param name="ArrayList:id">ArrayList ID</param>
    <returns>true jei ArrayList tuščias, false kitais atvejais</returns>
*/
stock ArrayListIsEmpty(ArrayList:id)
{
    if(!ArrayListSize(id))
        return true;
    else
        return false;
}

/**
    <summary>ArrayListIsEmpty</summary>
    <param name="ArrayList:id">ArrayList ID</param>
    <returns>true jei ArrayList ID yra tinkamas, false kitais atvejais</returns>
*/
stock IsValidArrayList(ArrayList:id)
{
    if(id < 0 || id >= Malloc_SlotSize(gListMemory) || gListMemory == NO_ALLOC)
        return false;
    else
        return true;
}


/**
    <summary>ArrayListDestroy</summary>
    <param name="ArrayList:id">ArrayList ID</param>
    <returns>true sėkmingai sunaikinus ArrayList, false kitais atvejais</returns>

    <remarks>Sunaikinus ArrayList bus prarastas visas jo turinys</remarks>
*/
stock ArrayListDestroy(ArrayList:id)
{
    if(!IsValidArrayList(id))
        return false;

    new Alloc:tmp = Malloc_SlotSize(gListMemory)-1;
    if(tmp == NO_ALLOC)
    {
        print("Error. ArrayListDestroy : Failed allocating memory.");
        return false;
    }
    for(new i = 0; i < Malloc_SlotSize(gListMemory); i++)
    {
        // There is no such arraylist.
        if(i == Malloc_SlotSize(gListMemory))
        {
            free(tmp);
            return false;
        }
        if(mget(gListMemory, i) == id)
            continue;
        else
            mset(tmp, count++, mget(gListMemory, i));
    }
    free(gListMemory);
    gListMemory = tmp;
    return true;
}

/**
    <summary>ArrayListMerge</summary>
    <param name="ArrayList:id">Pirmojo ArrayList ID</param>
    <param name="&amp;ArrayList:id2">Antrojo ArrayList ID</param>
    <returns>Naujo ArrayList ID</returns>

    <remarks>Sujungto masyvo ID bus lygus pateikto ArrayList ID</remarks>
*/
stock ArrayListMerge(ArrayList:id, &ArrayList:id2)
{
    if(!IsValidArrayList(id) || !IsValidArrayList(id2));
        return INVALID_ARRAYLIST_ID;

    new Alloc:list = Alloc:mget(gListMemory, id),
        Alloc:list2 = Alloc:mget(gListMemory, id2);
    if(list == NO_ALLOC || list2 == NO_ALLOC)
        return INVALID_ARRAYLIST_ID;

    new Alloc:tmp = malloc(Malloc_SlotSize(list) + Malloc_SlotSize(list2));
    if(tmp == NO_ALLOC)
    {
        print("Error. ArrayListMerge : Failed allocating memory.");
        return INVALID_ARRAYLIST_ID;
    }
    new count = 0;
    for(new i = 0; i < Malloc_SlotSize(list); i++)
        msete(tmp, count++, mget(list, i));
    for(new i = 0; i < Malloc_SlotSize(list2); i++)
        msete(tmp, count++, mget(list2, i));
    free(list);
    free(list2);

    // Remove second array reference from the list memory
    ArrayListDestroy(id2);
    id2 = INVALID_ARRAYLIST_ID;

    // Store new new array instead of id.
    mset(gListMemory, id, tmp);
    return id;
}


static stock IsValidArrayListIndex(ArrayList:id, index)
{
    if(!IsValidArrayList(id) || index < 0)
        return false;
    new Alloc:tmp = Alloc:mget(gListMemory, id);
    if(tmp == NO_ALLOC || index >= Malloc_SlotSize(tmp))
        return false;
    return true;
}