array.hpp

Go to the documentation of this file.

 
#ifndef ARRAY_HPP
#define ARRAY_HPP
 
#include <stdbool.h>
#include <stdint.h>
#include <initializer_list>
#include <iostream>
#include "delete.hpp"
#include "access.hpp"
#include "object.hpp"
#include <string.h>
 
namespace BF {
 
template <typename T, typename S = size_t> class Array : public Object {
public:
    Array() : Object() {
        this->_address = 0;
        this->_count = 0;
        this->_callback = Array::comparisonDefault;
        this->_releasecb = NULL;
    }
 
    Array(T * array, S size) : Array() {
        this->set(array, size); 
    }
 
    Array(std::initializer_list<T> list) : Array() {
        this->set(list);
    }
 
    virtual ~Array() {
        this->removeAll();
    }
 
    void removeAll() {
        // if there is a release callback
        // then let's call this
        //
        // this callback handles the memory of each element. This
        // is set by the owner of this object
        if (this->_releasecb) {
            for (S i = 0; i < this->_count; i++) {
                this->_releasecb((this->_address)[i]);
            }
        }
        
        this->deallocate(this->_address);
        this->_address = 0;
        this->_count = 0;
    }
    
    void set(T * array, S size) {
        this->saveArray(array, size);   
    }
 
    void set(std::initializer_list<T> list) {
        this->saveArray(list);
    }
 
    [[deprecated("allocation is no longer configurable")]]
    void setAllocationCallback(T * (* cb) (S size)) {
        //this->_allocationCallback = cb;
    }
 
    [[deprecated("allocation is no longer configurable")]]
    void setDeallocationCallback(void (* cb) (T * value)) {
        //this->_deallocationCallback = cb;
    }
 
    virtual bool contains(T object) {
        for (S i = 0; i < this->_count; i++) {
            if (    this->_callback((this->_address)[i], object) 
                ==  0) 
                return true;
        }
        return false;
    }
 
    T objectAtIndex(S index) const {
        if ((this->_address == 0) || (this->_count == 0)) {
            return (T) 0;
        } else if (index >= this->_count) {
            return (T) 0;
        } else {
            return this->_address[index];
        }
    }
 
    S indexForObject(T object) const {
        for (S i = 0; i < this->_count; i++) {
            if (    this->_callback(this->_address[i], object)
                ==  0)
                return i;
        }
        return -1;
    }
 
    virtual S count() const {
        return this->_count;
    }
 
    virtual void print() {
        std::cout << "[ ";
        for (S i = 0; i < this->_count; i++) {
            std::cout << this->_address[i];
            std::cout << " ";
        }
        std::cout << "]" << std::endl;
    }
 
    void setComparator(int (* callback) (T a, T b)) {
        this->_callback = callback;
    }
 
    void setReleaseCallback(void (* callback) (T obj)) {
        this->_releasecb = callback;
    }
 
    void copyFromArray(const Array<T> * arr) {
        this->removeAll();
        this->_address = (T *) this->allocate(arr->count());
        this->_count = arr->count();
        memcpy(this->_address, arr->address(), this->_count);
    }
 
    int add(T obj) {
        this->_address = this->reallocate(this->_address, this->_count + 1);
        if (this->_address == NULL) {
            this->_count = 0;
            return -3;
        }
 
        this->_count++;
        this->_address[this->_count - 1] = obj;
        return 0;
    }
 
    int insertObjectAtIndex(T obj, S index) {
        this->_address = this->reallocate(this->_address, this->_count + 1);
        if (this->_address == NULL) {
            this->_count = 0;
            return -4;
        }
 
        // shift
        this->_count++;
        for (S i = this->_count - 1; i > index; i--) {
            this->_address[i] = this->_address[i - 1];
        }
 
        this->_address[index] = obj;
 
        return 0;
    }
 
    int removeObjectAtIndex(S index) {
        // shift objects
        for (S i = index; (i+1) < this->_count; i++) {
            this->_address[i] = this->_address[i + 1];
        }
 
        // adjust array
        this->_count--;
        this->_address = this->reallocate(this->_address, this->_count);
 
        // if count == 0, then realloc will return NULL
        if (this->_count && (this->_address == NULL)) {
            this->_count = 0;
            return -5;
        }
 
        return 0;
    }
 
protected:
 
    T * address() const { return this->_address; }
    
private:
 
    static T * allocate(S size) {
        return (T *) malloc(sizeof(T) * size);
    }
 
    static T * reallocate(T * addr, S newsize) {
        return (T *) realloc(addr, sizeof(T) * newsize);
    }
 
    static void deallocate(T * value) {
        free((void *) value);
    }
 
    void saveArray(T * array, S size) {
        this->removeAll();
        this->_address = (T *) this->allocate(size);
        this->_count = size;
 
        if (this->_address) {
            // Load into array
            for (S i = 0; i < size; i++) {
                this->_address[i] = array[i];
            }
        }
    }
 
    void saveArray(std::initializer_list<T> list) {
        this->removeAll();
        typename std::initializer_list<T>::iterator itr;
 
        this->_count = list.size();
        this->_address = (T *) this->allocate(this->_count);
 
        if (this->_address) {
            S i = 0;
            for (itr = list.begin(); itr != list.end(); ++itr) {
                this->_address[i] = *itr;
                i++;
            }
        }
    }
 
    T * _address;
 
    S _count;
 
    int (* _callback) (T a, T b);
 
    void (* _releasecb) (T obj);
 
public:
 
    T operator[](S index) const {
        return this->objectAtIndex(index);
    }
 
    void operator=(const std::initializer_list<T> & list) {
        this->saveArray(list);
    }
 
    Array<T> & operator=(const Array<T> & arr) {
        this->copyFromArray(&arr);
        return *this;
    }
 
// Comparators
public:
    static int comparisonDefault(T a, T b) {
        if (a < b) {
            return -1;
        } else if (a > b) {
            return 1;
        } else {
            return 0;
        }
    }
};
 
} // namespace BF
 
#endif // ARRAY_HPP