Collection.h

Zobrazit dokumentaci tohoto souboru.

#ifndef _HCOLLECTION_
#define _HCOLLECTION_

#include "main.h"

template<class T>
class CCollection {

public:

        CCollection();
        virtual ~CCollection();

        void add(T* item); // prida prvek do kolekce
        void add(T** item, int count); // prida vice prvku
        bool remove(int index); // odebere prvek z kolekce
        virtual void clean(); // totalne vycisti kolekci
        void resize(); // zvetsi kapacitu kolekce
        int getLastInsertID(){ return m_size - 1; };

        void lock(int position) {
                m_lockAt = position;
        }

        int getLockPos() {
                return m_lockAt;
        }

        void unlock() {
                m_lockAt = -1;
        }

        bool isLocked() const {
                return m_lockAt >= 0 ? true : false;
        }

        int size() const {
                return m_size;
        }
         // vrati pocet prvku kolekce
        T* get(int index); // vraci prvek na dane pozici

protected:

        int m_capacity; // kapacita kolekce
        int m_size; // mohutnost kolekce
        int m_lockAt; // uzamceni obsahu od pozice 0 - m_lockAt

        T** m_data; // prvky kolekce

};

template<class T>
CCollection<T>::CCollection() {

        cout << "Create collection" << endl;

        m_lockAt = -1; // zadny obsah neni zamceny
        m_capacity = 32; // implicitni kapacita
        m_size = 0; // pocatecni obsah

        m_data = new T*[m_capacity]; // alokace pameti pro prvky

        for (int i = 0; i < m_capacity; i++) { // inicializace
                this->m_data[i] = NULL;
        }

}

template<class T>
CCollection<T>::~CCollection() {
        unlock();
        clean();

        if(m_data != NULL){
                delete [] m_data;
                m_data = NULL;
        }

}

template<class T>
void CCollection<T>::clean() {

        cout << "Clean Up Collection " << endl;

        if (m_data != NULL) {

                int _size = m_size;
                for (int i = 0; i < _size; i++) {
                        if(m_data[i] != NULL){
                                delete m_data[i];
                                m_data[i] = NULL;
                        }
                        m_size--;
                }
        }

}

template<class T>
void CCollection<T>::resize() {

        cout << "TOGLE JA ZVETSUJI" << endl;

        m_capacity *= 2; // zdvojnasobime kapacitu
        T** newData = new T*[m_capacity]; // alokujeme novy vetsi prostor

        for (int i = 0; i < m_size; i++) { // prekopirovani dosavadniho obsahu
                newData[i] = m_data[i];
        }

        for (int i = m_size; i < m_capacity; i++) { // inicializace prazdnych mist
                newData[i] = NULL;
        }

        delete[] m_data; // smazeme stare pole

        m_data = newData; // nastavime nove vetsi pole
}

template<class T>
bool CCollection<T>::remove(int index) {

        if (index >= m_size) {
                return false;
        }

        if (m_data[index] == NULL) {
                return false;
        } else {
                delete m_data[index];
        }

        m_data[index] = NULL;

        return true;
}

template<class T>
void CCollection<T>::add(T* item) {

        if (item == NULL) {
                return;
        }

        if (m_size + 1 >= m_capacity) {
                resize();
        }

        m_data[m_size++] = item;

}

template<class T>
void CCollection<T>::add(T** item, int count) {

        for (int i = 0; i < count; i++) {
                if (item[i] != NULL) {
                        add(item[i]);
                }
        }

}

template<class T>
T* CCollection<T>::get(int index) {

        if (index >= m_size || index < 0 || m_data == NULL) {
                return NULL;
        }

        if (m_data[index] == NULL) {
                return NULL;
        }

        return m_data[index];
}

#endif

---