From 0a73e2a0e52c1e6675b1ef883de7f2a64e26c559 Mon Sep 17 00:00:00 2001 From: fcolin Date: Thu, 1 Feb 2007 12:54:16 +0000 Subject: Utilisateur : Fcolin Date : 2/02/01 Heure : 18:30 Archivé dans $/Ivy Commentaire: win CE compile not finished (vss 3) --- Bus/Ivy/DataTypes.h | 321 +++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 268 insertions(+), 53 deletions(-) (limited to 'Bus/Ivy') diff --git a/Bus/Ivy/DataTypes.h b/Bus/Ivy/DataTypes.h index 53bef2b..85be4d6 100644 --- a/Bus/Ivy/DataTypes.h +++ b/Bus/Ivy/DataTypes.h @@ -11,71 +11,286 @@ class _declspec(dllimport) string; class string { public: - string(); - string( const char * s); - int length(); - bool empty(); - void erase(int start=0, int len = -1); - void append( const char *s , int len ); - void insert(int index, const char * s); - string substr( int start, int len = -1 ); - int find_first_of( const char* s ); - int rfind( char c ); - operator +=(string s); - string operator +(string s); + string(size_t len = 0) + { ptr = allocBuffer( len ); }; + string ( const string& s ) + { ptr = 0; copy( s.ptr, s.size ); } + string( const char * s, int len = -1 ) + { + ptr = 0; + if ( len < 0 ) + len = strlen(s) ; + copy( s, len ); + } + + ~string() + { delete ptr; } + size_t length() + { return size; } + bool empty() const + { return size==0; } + void copy( const char * s, int len ) + { + char *newptr = allocBuffer( len ); + strncpy( newptr, s, len ); + if ( ptr ) delete [] ptr; + ptr = newptr; + } + void erase(int start=0, int len = -1) + { + char *newptr; + size_t real_len; + real_len = len < 0 ? size - start : len; + if ( real_len > size ) real_len = size; + newptr = allocBuffer( size - real_len ); + strncpy( newptr, ptr , start ); + strncpy( &newptr[start], &ptr[start+real_len], size - start ); + delete ptr; + ptr = newptr; + } + void append( const char *s , int len = -1 ) + { + insert ( size, s , len ); + } + void insert(int index, const char * s, int len = -1) + { + char *newptr; + if ( len < 0 ) len = strlen(s) ; + newptr = allocBuffer( size + len ); + strncpy( newptr , ptr, index ); + strncpy( newptr+index , s, len ) ; + strncpy( newptr+index+len , &ptr[index], len ) ; + delete ptr; + ptr = newptr; + } + string substr( int start, int len = -1 ) + { return string ( &ptr[start], len ); } + int find_first_of( const char* strCharSet ) + { char *fnd = strpbrk( ptr, strCharSet ); if ( fnd ) return fnd - ptr; else return -1; } + int rfind( char c ) + { char *fnd = strrchr( ptr, c); if ( fnd ) return fnd - ptr; else return -1; } +// friend string operator + (const string& left, const char* right); +// friend string operator + (const char* left, const string& right); + friend string operator + (const string& left, const string& right) + { + string str( left.size + right.size ); + str.append( left.ptr, left.size); + str.append( right.ptr, right.size); + return str; + } + operator +=(string s) + { + append( s.ptr, s.size ); + } + operator +=(char c) + { append( &c, 1);} + string operator +(string s) const + { string str ( ptr, size ); str.append( s.ptr, s.size ); return str; } + string operator +(const char c) const + { string str ( ptr, size ); str.append( &c, 1); return str; } + string& operator=(const string& s) + { copy(s.ptr,s.size); return *this; } + string& operator=(const char* s) + { copy(s,strlen(s)); return *this; } // Nondestructive typecast operator - operator const char*() const; - const char *c_str() const; // remove this ugly thing + operator const char*() const + { return ptr; } + const char *c_str() const // remove this ugly thing + { return ptr; } +private: + char *ptr; + size_t size; + // always allocate one extra character for '\0' termination + char *allocBuffer(int len) + { + char *newptr; + size = len; + newptr = new char[len+1] ; + newptr[len] = '\0'; + return newptr; + } + }; -template class Iterator { -public: - T & operator !=(Iterator i); - T & operator ++(); - operator const T*() const; - T & second; -}; template class list { + +protected: + struct _Node; + friend struct _Node; + typedef struct _Node Node; + typedef Node* NodePtr; + struct _Node { + NodePtr next, prev; + T value; + }; + public: - void clear(); - bool empty(); - T front(); - pop_front(); - void push_back( T data ); - typedef Iterator iterator; - iterator begin(); - iterator end(); - void remove( T data ); + + friend class iterator; + class iterator { + public: + iterator() + {ptr = 0;} + iterator(NodePtr p) + {ptr = p;} + T& operator*() const + {return ptr->value; } + T* operator->() const + {return &(ptr->value); } + iterator& operator++() + {ptr = ptr->next; + return (*this); } + iterator operator++(int) + {iterator tmp = *this; + ++*this; + return (tmp); } + iterator& operator--() + {ptr = ptr.prev;); + return (*this); } + iterator operator--(int) + {iterator tmp = *this; + --*this; + return (tmp); } + bool operator==(const iterator& p) const + {return (ptr == p.ptr); } + bool operator!=(const iterator& p) const + {return (ptr != p.ptr); } + NodePtr next() const + {return ptr->next; }; + NodePtr prev() const + {return ptr->prev ; }; + NodePtr node() const + {return (ptr); } + protected: + NodePtr ptr; + }; + + list() + { head = 0; } + bool empty() + { return head == 0 ; } + T& front() + {return head->value; } + iterator erase(iterator n) + { + NodePtr p = n.prev(); + NodePtr s = (n++).node(); + delete p->next; + p->next = s; + s->prev = p; + return n; + } + void pop_front() + { + NodePtr newhead = head->next; + newhead->prev = head->prev; + head->prev->next = newhead; + delete head; + head = (head == newhead) ? 0 : newhead; + } + iterator erase(iterator first, iterator last) + { + while (first != last) + erase(first++); + return (first); + } + void clear() + {erase(begin(), end()); } + void push_back( T value ) + { + NodePtr p = new Node; + p->value = value; + if ( head ) + { + p->next = head; + p->prev = head->prev; + head->prev->next = p; + head->prev = p; + } + else { + head = p; + p->next = p->prev = p; + } + } + void remove( const T& data ) + { + iterator last = end(); + for (iterator iter = begin(); iter != last; ) + if (*iter == data) + erase(iter++); + else + ++iter; + } + iterator begin() + {return (iterator(head)); } + iterator end() + { + if (head ) + return (iterator(head->prev)); + else return (iterator(head)); + } + protected: + NodePtr head; + }; template class vector { public: - void clear(); - int size(); - // Nondestructive typecast operator - operator const T*() const; - // Accesses indexed component of vector - T & operator [](int i); + + vector ( ) + { data = 0; len = 0; } + size_t size() + { return len; } + void reserve( size_t index ) + { + if ( index >= len ) + { + size_t i; + T* newdata = new T[index+1]; + for ( i = 0; i < len ; i ++ ) + newdata[i] = data[i]; + for ( i = len; i < index+1 ; i ++ ) + newdata[i] = 0; + if ( data ) delete [] data; + data = newdata; + len = index+1; + } + } // Accesses indexed component of vector - const T & operator [](int i) const; - void push_back( T data ); - void remove( T data ); - + T & operator [](size_t index ) + { + // reserve( index ); // TODO or NOT check range + return data[index] ; + } + T & operator [](size_t index ) const + { + return data[index] ; + } + void push_back( const T& value ) + { + T* newdata = new T[len+1]; + for ( unsigned int i = 0; i < len ; i ++ ) + newdata[i] = data[i]; + newdata[len++] = value; + if ( data ) delete [] data; + data = newdata; + } + void erase( int i ) + { + data[i] = 0; + } + void clear() + { + delete [] data; + data = 0; + len = 0; + } + +private: + T* data; + size_t len; }; -template class map { -public: - void clear(); - int size(); - bool empty(); - find(I i ); - typedef Iterator iterator; - iterator begin(); - iterator end(); - void erase( I i ); - // Accesses indexed component of vector - const T & operator [](I i) const; -}; \ No newline at end of file -- cgit v1.1