cs sdk v 1.14 released Home  |  Product  |  Documents  |  Tutorials  |  FAQ |   Download  |   Forum |   Contacts  |   Link     Cross Suit  Cross Suit SDK  Documents       classes  Starting...            Tutorials  LUA tutorials    Support   Forum   q&a  Product parts  Virtual File system  Virtual Render  Virtual Machine       Demo Games      3D Engine   gvSystem(dx9)  Link     gv_arraylist.h Go to the documentation of this file. /****************************************************** gv System engine 3D/2D *******************************************************/ #pragma once class gv_arrayPTR { enum gv_arrayPTRType { gv_arrayPTR_VALUE, // entry data is copied into the list gv_arrayPTR_REFERENCE, // entry pointers are copied into the list }; protected: gv_arrayPTRType m_ArrayListType; void* m_pData; unsigned int m_BytesPerEntry; unsigned int m_NumEntries; unsigned int m_NumEntriesAllocated; public: gv_arrayPTR( gv_arrayPTRType Type=gv_arrayPTR_VALUE, unsigned int BytesPerEntry = 0 ); virtual ~gv_arrayPTR( void ); virtual int Add( void* pEntry ); virtual void Remove( unsigned int Entry ); virtual void* GetPtr( unsigned int Entry ); virtual unsigned int Count( void ) { return m_NumEntries; } virtual bool Contains( void* pEntryDsata ); virtual bool Contains( void* pEntryData, int& nIndex ); virtual void Clear( void ) { m_NumEntries = 0; } }; template <class T>//, typename TAlloc = irrAllocator<T> > class geArray { public: geArray() : data(0), allocated(0), used(0), free_when_destroyed(true), is_sorted(true) { } geArray(unsigned int start_count) : data(0), allocated(0), used(0), free_when_destroyed(true), is_sorted(true) { reallocate(start_count); } geArray(const geArray<T>& other) : data(0) { *this = other; } ~geArray() { if (free_when_destroyed) { //for (unsigned int i=0; i<used; ++i) // delete (&data[i]); if(data) delete []data; } } void reallocate(unsigned int new_size) { // patch; if(new_size==0) return; T* old_data = data; //data = allocator.allocate(new_size); //new T[new_size]; data =new T[new_size]; allocated = new_size; // copy old data signed int end = used < new_size ? used : new_size; for (signed int i=0; i<end; ++i) { data[i] = old_data[i]; //allocator.construct(&data[i], old_data[i]); } // destruct old data //for (unsigned int j=0; j<used; ++j) // allocator.destruct(&old_data[j]); // ÆÐÄ¡. // if(old_data) // delete []old_data; if (allocated < used) used = allocated; //allocator.deallocate(old_data); //delete [] old_data; if(old_data) delete []old_data; } void push_back(const T& element) { if (used + 1 > allocated) { // reallocate(used * 2 +1); // this doesn't work if the element is in the same geArray. So // we'll copy the element first to be sure we'll get no data // corruption T e(element); reallocate(used * 2 +1); // increase data block //allocator.construct(&data[used++], e); // data[used++] = e; // push_back data[used++] = e; is_sorted = false; return; } data[used++] = element; // instead of using this here, we copy it the safe way: //allocator.construct(&data[used++], element); is_sorted = false; } void push_front(const T& element) { if (used + 1 > allocated) reallocate(used * 2 +1); for (int i=(int)used; i>0; --i) { data[i] = data[i-1]; //allocator.construct(&data[i], data[i-1]); } data[0] = element; //allocator.construct(&data[0], element); is_sorted = false; ++used; } void insert(const T& element, unsigned int index=0) { //gv_assert_true(index>used) // access violation if (used + 1 > allocated) reallocate(used * 2 +1); for (unsigned int i=used++; i>index; i--) //allocator.construct(&data[i], data[i-1]); // data[i] = data[i-1]; data[i] = data[i-1]; //allocator.construct(&data[index], element); // data[index] = element; data[index] = element; is_sorted = false; } void clear() { //for (unsigned int i=0; i<used; ++i) // allocator.destruct(&data[i]); //allocator.deallocate(data); // delete [] data; if(data) delete [] data; data = 0; used = 0; allocated = 0; is_sorted = true; } void set_pointer(T* newPointer, unsigned int size) { //for (unsigned int i=0; i<used; ++i) // allocator.destruct(&data[i]); //allocator.deallocate(data); // delete [] data; delete [] data; data = newPointer; allocated = size; used = size; is_sorted = false; } void set_free_when_destroyed(bool f) { free_when_destroyed = f; } void set_used(unsigned int usedNow) { if (allocated < usedNow) reallocate(usedNow); used = usedNow; } void operator=(const geArray<T>& other) { if (data) { //for (unsigned int i=0; i<used; ++i) // delete allocator.destruct(&data[i]); //allocator.deallocate(data); // delete [] data; delete [] data; } //if (allocated < other.allocated) if (other.allocated == 0) data = 0; else data = new T[other.allocated];//allocator.allocate(other.allocated); // new T[other.allocated]; used = other.used; free_when_destroyed = other.free_when_destroyed; is_sorted = other.is_sorted; allocated = other.allocated; for (unsigned int i=0; i<other.used; ++i) //allocator.construct(&data[i], other.data[i]); // data[i] = other.data[i]; data[i] = other.data[i]; } //#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) if (_CONDITION_) {_asm int 3} T& operator [](unsigned int index) { //gv_assert_true(index>=used) // access violation return data[index]; } const T& operator [](unsigned int index) const { // gv_assert_true(index>=used) // access violation return data[index]; } T& getLast() { // gv_assert_true(!used) // access violation return data[used-1]; } const T& getLast() const { // gv_assert_true(!used) // access violation return data[used-1]; } T* pointer() { return data; } const T* const_pointer() const { return data; } unsigned int size() const { return used; } unsigned int allocated_size() const { return allocated; } bool empty() const { return used == 0; } void sort() { if (is_sorted || used<2) return; heapsort(data, used); is_sorted = true; } signed int binary_search(const T& element) { return binary_search(element, 0, used-1); } signed int binary_search(const T& element, signed int left, signed int right) { if (!used) return -1; sort(); signed int m; do { m = (left+right)>>1; if (element < data[m]) right = m - 1; else left = m + 1; } while((element < data[m] || data[m] < element) && left<=right); // this last line equals to: // " while((element != geArray[m]) && left<=right);" // but we only want to use the '<' operator. // the same in next line, it is "(element == geArray[m])" if (!(element < data[m]) && !(data[m] < element)) return m; return -1; } signed int linear_search(const T& element) const { for (unsigned int i=0; i<used; ++i) if (!(element < data[i]) && !(data[i] < element)) return (signed int)i; return -1; } signed int linear_reverse_search(const T& element) const { for (signed int i=used-1; i>=0; --i) if (data[i] == element) return (signed int)i; return -1; } void erase(unsigned int index) { //_IRR_DEBUG_BREAK_IF(index>=used) // access violation //gv_assert_true(index>used) // access violation for (unsigned int i=index+1; i<used; ++i) { //allocator.destruct(&data[i-1]); //allocator.construct(&data[i-1], data[i]); // data[i-1] = data[i]; delete &data[i-1]; data[i-1] = data[i]; } //allocator.destruct(&data[used-1]); --used; } void erase(unsigned int index, signed int count) { //gv_assert_true(index>=used || count<1 || index+count>used) // access violation unsigned int i; for (i=index; i<index+count; ++i) { //allocator.destruct(&data[i]); delete &data[i]; } for (i=index+count; i<used; ++i) { if (i > index+count) { //allocator.destruct(&data[i-count]); delete &data[i-count]; data[i-count]=0x00; } //allocator.construct(&data[i-count], data[i]); // data[i-count] = data[i]; data[i-count] = data[i]; if (i >= used-count) { //allocator.destruct(&data[i]); delete &data[i]; data[i]=0x00; } } used-= count; } void set_sorted(bool _is_sorted) { is_sorted = _is_sorted; } private: T* data; unsigned int allocated; unsigned int used; bool free_when_destroyed; bool is_sorted; //TAlloc allocator; }; template <typename T>//, typename TAlloc = irrAllocator<T> > class gvString { private: //--- member variables T* array; signed int allocated; signed int used; //TAlloc allocator; public: gvString() : array(0), allocated(1), used(1) { array = new T[1]; array[0] = 0x0; } gvString(const gvString<T>& other) : array(0), allocated(0), used(0) { *this = other; } gvString(double number) : array(0), allocated(0), used(0) { char tmpbuf[255]; sprintf(tmpbuf,"%0.6f",number); *this = tmpbuf; } gvString(int number) : array(0), allocated(0), used(0) { // store if negative and make positive bool negative = false; if (number < 0) { number *= -1; negative = true; } // temporary buffer for 16 numbers char tmpbuf[16]; tmpbuf[15] = 0; signed int idx = 15; // special case '0' if (!number) { tmpbuf[14] = '0'; *this = &tmpbuf[14]; return; } // add numbers while(number && idx) { idx--; tmpbuf[idx] = (char)('0' + (number % 10)); number = number / 10; } // add sign if (negative) { idx--; tmpbuf[idx] = '-'; } *this = &tmpbuf[idx]; } template <class B> gvString(const B* c, signed int length) : array(0), allocated(0), used(0) { if (!c) return; allocated = used = length+1; array = new T[used];//allocator.allocate(used); // new T[used]; for (signed int l = 0; l<length; ++l) array[l] = (T)c[l]; array[length] = 0; } template <class B> gvString(const B* c) : array(0), allocated(0), used(0) { *this = c; } ~gvString() { delete [] array; } gvString<T>& operator=(const gvString<T>& other) { if (this == &other) return *this; if(array) delete [] array; allocated = used = other.size()+1; array = new T[used]; const T* p = other.c_str(); for (signed int i=0; i<used; ++i, ++p) array[i] = *p; return *this; } template <class B> gvString<T>& operator=(const B* c) { if (!c) { if (!array) { array = new T[1];//allocator.allocate(1); //new T[1]; allocated = 1; } used = 1; array[0] = 0x0; return *this; } if ((void*)c == (void*)array) return *this; signed int len = 0; const B* p = c; while(*p) { ++len; ++p; } // we'll take the old string for a while, because the new // string could be a part of the current string. T* oldArray = array; allocated = used = len+1; array = new T[used]; for (signed int l = 0; l<len+1; ++l) array[l] = (T)c[l]; if(oldArray) delete [] oldArray; return *this; } gvString<T> operator+(const gvString<T>& other) const { gvString<T> str(*this); str.append(other); return str; } template <class B> gvString<T> operator+(const B* c) const { gvString<T> str(*this); str.append(c); return str; } T& operator [](const signed int index) const { //gv_assert_true(index>=used) // bad index return array[index]; } bool operator ==(const T* str) const { if (!str) return false; signed int i; for(i=0; array[i] && str[i]; ++i) if (array[i] != str[i]) return false; return !array[i] && !str[i]; } bool operator ==(const gvString<T>& other) const { for(signed int i=0; array[i] && other.array[i]; ++i) if (array[i] != other.array[i]) return false; return used == other.used; } bool operator <(const gvString<T>& other) const { for(signed int i=0; array[i] && other.array[i]; ++i) if (array[i] != other.array[i]) return (array[i] < other.array[i]); return used < other.used; } bool operator !=(const T* str) const { return !(*this == str); } bool operator !=(const gvString<T>& other) const { return !(*this == other); } signed int size() const { return used-1; } const T* c_str() const { return array; } void make_lower() { const T A = (T)'A'; const T Z = (T)'Z'; const T diff = (T)'a' - A; for (signed int i=0; i<used; ++i) { if (array[i]>=A && array[i]<=Z) array[i] += diff; } } void make_upper() { const T a = (T)'a'; const T z = (T)'z'; const T diff = (T)'A' - a; for (signed int i=0; i<used; ++i) { if (array[i]>=a && array[i]<=z) array[i] += diff; } } bool equals_ignore_case(const gvString<T>& other) const { for(signed int i=0; array[i] && other[i]; ++i) if (toLower(array[i]) != toLower(other[i])) return false; return used == other.used; } bool equalsn(const gvString<T>& other, int len) const { int i; for(i=0; array[i] && other[i] && i < len; ++i) if (array[i] != other[i]) return false; // if one (or both) of the strings was smaller then they // are only equal if they have the same length return (i == len) || (used == other.used); } bool equalsn(const T* str, int len) const { if (!str) return false; int i; for(i=0; array[i] && str[i] && i < len; ++i) if (array[i] != str[i]) return false; // if one (or both) of the strings was smaller then they // are only equal if they have the same length return (i == len) || (array[i] == 0 && str[i] == 0); } void append(T character) { if (used + 1 > allocated) reallocate((signed int)used + 1); used += 1; array[used-2] = character; array[used-1] = 0; } void append(const T* other) { if (!other) return; --used; signed int len = 0; const T* p = other; while(*p) { ++len; ++p; } if (used + len + 1 > allocated) reallocate((signed int)used + (signed int)len + 1); for (signed int l=0; l<len+1; ++l) array[l+used] = *(other+l); used = used + len + 1; } void append(const gvString<T>& other) { --used; signed int len = other.size(); if (used + len + 1 > allocated) reallocate((signed int)used + (signed int)len + 1); for (signed int l=0; l<len+1; ++l) array[l+used] = other[l]; used = used + len + 1; } void append(const gvString<T>& other, signed int length) { signed int len = other.size(); if (len < length) { append(other); return; } len = length; --used; if (used + len > allocated) reallocate((signed int)used + (signed int)len); for (signed int l=0; l<len; ++l) array[l+used] = other[l]; used = used + len; } void reserve(signed int count) { if (count < allocated) return; reallocate(count); } signed int findFirst(T c) const { for (signed int i=0; i<used; ++i) if (array[i] == c) return i; return -1; } signed int findFirstChar(T* c, int count) const { if (!c) return -1; for (signed int i=0; i<used; ++i) for (int j=0; j<count; ++j) if (array[i] == c[j]) return i; return -1; } template <class B> signed int findFirstCharNotInList(B* c, int count) const { for (int i=0; i<used; ++i) { int j; for (j=0; j<count; ++j) if (array[i] == c[j]) break; if (j==count) return i; } return -1; } template <class B> signed int findLastCharNotInList(B* c, int count) const { for (int i=used-2; i>=0; --i) { int j; for (j=0; j<count; ++j) if (array[i] == c[j]) break; if (j==count) return i; } return -1; } signed int findNext(T c, signed int startPos) const { for (signed int i=startPos; i<used; ++i) if (array[i] == c) return i; return -1; } signed int findLast(T c) const { for (signed int i=used-1; i>=0; --i) if (array[i] == c) return i; return -1; } template <class B> signed int find(B* str) const { if (str && *str) { int len = 0; while (str[len]) ++len; for (int i=0; i<(int)(used-len); ++i) { int j=0; while(str[j] && array[i+j] == str[j]) ++j; if (!str[j]) return i; } } return -1; } gvString<T> subString(signed int begin, signed int length) const { if (length <= 0) return gvString<T>(""); gvString<T> o; o.reserve(length+1); for (signed int i=0; i<length; ++i) o.array[i] = array[i+begin]; o.array[length] = 0; o.used = o.allocated; return o; } void operator += (T c) { append(c); } void operator += (const T* c) { append(c); } void operator += (const gvString<T>& other) { append(other); } void operator += (int i) { append(gvString<T>(i)); } void operator += (double i) { append(gvString<T>(i)); } void replace(T toReplace, T replaceWith) { for (signed int i=0; i<used; ++i) if (array[i] == toReplace) array[i] = replaceWith; } void trim() { const char whitespace[] = " \t\n\r"; const int whitespacecount = 4; // find start and end of real string without whitespace int begin = findFirstCharNotInList(whitespace, whitespacecount); if (begin == -1) return; int end = findLastCharNotInList(whitespace, whitespacecount); if (end == -1) return; *this = subString(begin, (end +1) - begin); } void erase(int index) { //gv_assert_true(index>=used || index<0) // access violation for (int i=index+1; i<used; ++i) array[i-1] = array[i]; --used; } private: T toLower(const T& t) const { if (t>=(T)'A' && t<=(T)'Z') return t + ((T)'a' - (T)'A'); else return t; } void reallocate(signed int new_size) { T* old_array = array; array = new T[new_size]; allocated = new_size; signed int amount = used < new_size ? used : new_size; for (signed int i=0; i<amount; ++i) array[i] = old_array[i]; if (allocated < used) used = allocated; delete [] old_array; } }; typedef gvString<char> stringc; typedef gvString<unsigned short /*wchar_t*/ > stringw; // typedef gvString<char> gvStringc; typedef gvString<unsigned short> gvStringw; // // template <class T> class gvList { private: struct SKListNode { SKListNode() : next(0), prev(0) {}; SKListNode* next; SKListNode* prev; T element; }; public: class Iterator { public: Iterator() : current(0) {}; Iterator& operator ++() { current = current->next; return *this; }; Iterator& operator --() { current = current->prev; return *this; }; Iterator operator ++(signed int) { Iterator tmp = *this; current = current->next; return tmp; }; Iterator operator --(signed int) { Iterator tmp = *this; current = current->prev; return tmp; }; Iterator operator+(signed int num) const { Iterator tmp = *this; if (num >= 0) while (num-- && tmp.current != 0) ++tmp; else while (num++ && tmp.current != 0) --tmp; return tmp; } Iterator& operator+=(signed int num) { if (num >= 0) while (num-- && this->current != 0) ++(*this); else while (num++ && this->current != 0) --(*this); return *this; } Iterator operator-(signed int num) const { return (*this)+(-num); } Iterator operator-=(signed int num) const { (*this)+=(-num); return *this; } bool operator ==(const Iterator& other) const { return current == other.current; }; bool operator !=(const Iterator& other) const { return current != other.current; }; T& operator *() { return current->element; }; private: Iterator(SKListNode* begin) : current(begin) {}; friend class gvList<T>; SKListNode* current; }; gvList() : root(0), last(0), size(0) {} gvList(const gvList<T>& other) { *this = other; } ~gvList() { clear(); } void operator=(const gvList<T>& other) { clear(); SKListNode* node = other.root; while(node) { push_back(node->element); node = node->next; } } unsigned int getSize() const { return size; } void clear() { SKListNode* node = root; while(node) { SKListNode* next = node->next; delete node; node = next; } root = 0; last = 0; size = 0; } bool empty() const { return root == 0; } void push_back(const T& element) { SKListNode* node = new SKListNode; node->element = element; ++size; if (root == 0) root = node; node->prev = last; if (last != 0) last->next = node; last = node; } void push_front(const T& element) { SKListNode* node = new SKListNode; node->element = element; ++size; if (root == 0) { last = node; root = node; } else { node->next = root; root->prev = node; root = node; } } Iterator begin() const { return Iterator(root); } Iterator end() const { return Iterator(0); } Iterator getLast() const { return Iterator(last); } void insert_after(Iterator& it, const T& element) { SKListNode* node = new SKListNode; node->element = element; node->next = it.current->next; if (it.current->next) it.current->next->prev = node; node->prev = it.current; it.current->next = node; ++size; if (it.current == last) last = node; } void insert_before(Iterator& it, const T& element) { SKListNode* node = new SKListNode; node->element = element; node->prev = it.current->prev; if (it.current->prev) it.current->prev->next = node; node->next = it.current; it.current->prev = node; ++size; if (it.current == root) root = node; } Iterator erase(Iterator& it) { Iterator returnIterator(it); ++returnIterator; if (it.current == root) root = it.current->next; if (it.current == last) last = it.current->prev; if (it.current->next) it.current->next->prev = it.current->prev; if (it.current->prev) it.current->prev->next = it.current->next; delete it.current; it.current = 0; --size; return returnIterator; } private: SKListNode* root; SKListNode* last; unsigned int size; }; // // /* template <class T,class TValue> class gvListEx { public: gvListEx(void) { } ~gvListEx(void) { clear(); } void clear(void) { mbase.clear(); mbaseValue.clear(); } // gvList<T> mbase; geArray<TValue> mbaseValue; // void operator=(const TValue& other) { mbaseValue.push_back(other); } // T& operator [](const T& other) { mbase.push_back(other); //mbaseValue.push_back(other); } // T* find(const char* string) { gvList<T>::Iterator it = mbase.begin(); for (; it != mbase.end(); ++it ) { if((*it)==string) //if(string==(*it)) // error return &(*it); } return mbase.end(); } }; */ Copyright(C) gvSystem & GamePlus All Rights Reserved.