ObjectPool.asc

//===========================================================================
//
// Array_ExpandIf()
// Takes array "arr" which supposedly is large enough to store "valid_count"
// number of elements. If "need_capacity" is greater than "valid_count", then
// creates a new array, copies old contents there, and returns it.
// Otherwise simply returns existing array.
//
//===========================================================================
import int[] Array_ExpandIf(int arr[], int valid_count, int need_capacity, int elem_sz = 1);

int[] Array_ExpandIf(int arr[], int valid_count, int need_capacity, int elem_sz)
{
    if (valid_count >= need_capacity) { return arr; }
    int want_space = need_capacity * elem_sz;
    int new_arr[] = new int[want_space];
    int took_space = valid_count * elem_sz;
    for (int i = 0; i < took_space; i++) {
        new_arr[i] = arr[i];
    }
    return new_arr;
}


//===========================================================================
//
// ObjectPool::AddObjects()
// Registers range of IDs.
//
//===========================================================================
void ObjectPool::AddObjects(int from, int to) {
    if (this._capacity <= to) {
        int new_capacity = to + 1;
        this._usingObj = Array_ExpandIf(this._usingObj, this._capacity, new_capacity);
        this._isFree = Array_ExpandIf(this._isFree, this._capacity, new_capacity);
        this._freeObj = Array_ExpandIf(this._freeObj, this._capacity, new_capacity);
        for (int i = this._capacity; i <= from; i++) {
            this._usingObj[i] = false;
            this._isFree[i] = false;
        }
        this._capacity = new_capacity;
    }
    for (int i = from; i <= to; i++) {
        if (!this._usingObj[i]) {
            this._freeObj[this._numFreeObj] = i;
            this._numFreeObj++;
            this._usingObj[i] = true;
            this._isFree[i] = true;
            this._numUsed++;
        }
    }
}

//===========================================================================
//
// ObjectPool::RemoveObjects()
// Unregisters range of IDs.
//
//===========================================================================
void ObjectPool::RemoveObjects(int from, int to) {
    for (int i = from; i <= to; i++) {
        if (this._usingObj[i]) {
            for (int j = 0; j < this._numFreeObj; j++) {
                if (this._freeObj[j] == i) {
                    for (; j < this._numFreeObj - 1; j++) {
                        this._freeObj[j] = this._freeObj[j + 1];
                    }
                    this._numFreeObj--;
                }
            }
            this._isFree[i] = false;
            this._usingObj[i] = false;
            this._numUsed--;
        }
    }
}

//===========================================================================
//
// ObjectPool::RemoveAll()
// Unregisters all IDs.
//
//===========================================================================
void ObjectPool::RemoveAll() {
    this._numFreeObj = 0;
    for (int i = 0; i < this._capacity; i++) {
        this._usingObj[i] = false;
        this._isFree[i] = false;
    }
    this._usingObj = null;
    this._isFree = null;
    this._freeObj = null;
    this._capacity = 0;
    this._numUsed = 0;
}

//===========================================================================
//
// ObjectPool::Acquire()
// Returns first found free ID and marks it as used.
//
//===========================================================================
int ObjectPool::Acquire() {
    if (this._numFreeObj == 0) { return -1; }
    this._numFreeObj--;
    int id = this._freeObj[this._numFreeObj];
    this._isFree[id] = false;
    return id;
}

//===========================================================================
//
// ObjectPool::Release()
// Marks given ID as free.
//
//===========================================================================
void ObjectPool::Release(int id) {
    if (!this._usingObj[id] || this._isFree[id]) { return; }
    this._freeObj[this._numFreeObj] = id;
    this._numFreeObj++;
    this._isFree[id] = true;
}

//===========================================================================
//
// ObjectPool::ReleaseAll()
// Marks all known IDs as free.
//
//===========================================================================
void ObjectPool::ReleaseAll() {
    this._numFreeObj = 0;
    for (int i = 0; i < this._capacity; i++) {
        if (this._usingObj[i]) {
            this._freeObj[this._numFreeObj] = i;
            this._numFreeObj++;
            this._isFree[i] = true;
        }
    }
}

//===========================================================================
//
// ObjectPool::GetAcquiredNum()
//
//===========================================================================
int ObjectPool::GetAcquiredNum() {
    return this._numUsed - this._numFreeObj;
}

//===========================================================================
//
// ObjectPool::GetFreeNum()
//
//===========================================================================
int ObjectPool::GetFreeNum() {
    return this._numFreeObj;
}

//===========================================================================
//
// ObjectPool::GetTotalNum()
//
//===========================================================================
int ObjectPool::GetTotalNum() {
    return this._numUsed;
}

#ifdef DEBUG
//===========================================================================
//
// ObjectPool::GetPoolSize()
//
//===========================================================================
int ObjectPool::GetPoolSize() {
    return this._capacity;
}
#endif // DEBUG