Subversion Repositories spk

Rev

Rev 1 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1 Rev 114
Line 36... Line 36...
36 
				const_reference operator * () const { return *m_ptr; }
 36 
				const_reference operator * () const { return *m_ptr; }
37 
				const_reference operator -> () const { return *m_ptr; }
 37 
				const_reference operator -> () const { return *m_ptr; }
38
38
39 
				bool operator ==(const_iterator& right)	const {	return right.m_ptr==m_ptr; }
 39 
				bool operator ==(const_iterator& right)	const {	return right.m_ptr==m_ptr; }
40 
				bool operator !=(const_iterator& right)	const {	return right.m_ptr!=m_ptr; }
 40 
				bool operator !=(const_iterator& right)	const {	return right.m_ptr!=m_ptr; }
- 
 
 41
- 
 
 42 
				const_iterator operator + (int i) { return const_iterator(m_ptr + i); }
41 
		};
 43 
		};
42
44
43 
		class iterator : public const_iterator
 45 
		class iterator : public const_iterator
44 
		{
 46 
		{
45 
			public:
 47 
			public:
Line 53... Line 55...
53 
				iterator& operator --()	{	m_ptr--; return *this; }
 55 
				iterator& operator --()	{	m_ptr--; return *this; }
54 
				iterator operator --(int)	{	m_ptr--; return iterator(m_ptr + 1); }
 56 
				iterator operator --(int)	{	m_ptr--; return iterator(m_ptr + 1); }
55
57
56 
				reference operator * () { return *m_ptr; }
 58 
				reference operator * () { return *m_ptr; }
57 
				reference operator -> () { return *m_ptr; }
 59 
				reference operator -> () { return *m_ptr; }
- 
 
 60
- 
 
 61 
				iterator operator + (int i) { return iterator(m_ptr + i); }
58 
		};
 62 
		};
59
63
60 
	protected:
 64 
	protected:
61 
		value_type *m_first, *m_last, *m_end;
 65 
		value_type *m_first, *m_last, *m_end;
62
66
63 
	private:
 67 
	private:
- 
 
 68 
		static const int DEFAULT_GROWBY = 100;
64 
		size_type m_growby;
 69 
		size_type m_growby;
65
70
66 
	public:
 71 
	public:
67 
		size_type size() const { return m_last - m_first; }
 72 
		size_type size() const { return m_last - m_first; }
68 
		size_type capacity() const { return m_end - m_first; }
 73 
		size_type capacity() const { return m_end - m_first; }
69
74
70 
		size_type growby() const { return m_growby; }
 75 
		size_type growby() const { return m_growby; }
71 
		void growby(size_type grow) const { m_growby=grow; }
 76 
		void growby(size_type grow) { m_growby=grow > 0 ? grow : DEFAULT_GROWBY; }
72
77
73 
		array() { m_growby=100; m_first=0; clear(); }
 78 
		array() { growby(DEFAULT_GROWBY); m_first=0; clear(); }
74 
		array(size_type size) { m_growby=100; m_first=0; clear(); resize(size); }
 79 
		array(size_type size) { growby(DEFAULT_GROWBY); m_first=0; clear(); resize(size); }
75 
		~array() { delete[] m_first; }
 80 
		~array() { delete[] m_first; }
76
81
77 
		void reserve(size_type newsize)
 82 
		void reserve(size_type newsize)
78 
		{
83 
		{
79 
			if(newsize > capacity()){
 84 
			if(newsize > capacity()){
Line 105... Line 110...
105
110
106 
		void clear()
 111 
		void clear()
107 
		{
 112 
		{
108 
			delete m_first;
 113 
			delete m_first;
109 
			m_first=0; m_last=0; m_end=0;
 114 
			m_first=0; m_last=0; m_end=0;
110 
		}
 115 
		}
111
116
112 
		reference operator[](difference_type offset) { return *(m_first + offset); }
 117 
		reference operator[](difference_type offset) { return *(m_first + offset); }
113 
		const_reference operator[](difference_type offset) const { return *(m_first + offset); }
 118 
		const_reference operator[](difference_type offset) const { return *(m_first + offset); }
114
119
115 
		reference at(difference_type offset) { return *(m_first + offset); }
 120 
		reference at(difference_type offset) { return *(m_first + offset); }
116 
		const_reference at(difference_type offset) const { return *(m_first + offset); }
 121 
		const_reference at(difference_type offset) const { return *(m_first + offset); }
Line 131... Line 136...
131 
		{
 136 
		{
132 
			if(size() == capacity())
 137 
			if(size() == capacity())
133 
				reserve(capacity() + growby());
 138 
				reserve(capacity() + growby());
134 
			*m_last=val;
 139 
			*m_last=val;
135 
			return iterator(m_last++);
 140 
			return iterator(m_last++);
- 
 
 141 
		}
- 
 
 142
- 
 
 143 
		void pop_back()
- 
 
 144 
		{
- 
 
 145 
			if(size())
- 
 
 146 
				m_last--;
136 
		}
 147 
		}
137
148
138 
		typedef int compare_callback (const void *, const void *);
 149 
		typedef int compare_callback (const void *, const void *);
139
150
140 
		void sort(compare_callback *callback)
 151 
		void sort(compare_callback *callback)
Line 147... Line 158...
147 
			reserve(size() + other.size());
 158 
			reserve(size() + other.size());
148 
			memcpy(m_first + size(), other.m_first, other.size() * sizeof(value_type));
 159 
			memcpy(m_first + size(), other.m_first, other.size() * sizeof(value_type));
149 
			m_last+=other.size();
 160 
			m_last+=other.size();
150 
		}
 161 
		}
151
162
- 
 
 163 
		iterator find(const_reference what)
- 
 
 164 
		{
- 
 
 165 
			iterator it;
- 
 
 166 
			for(it=begin(); it!=end(); ++it){
- 
 
 167 
				if(*it==what)
- 
 
 168 
					break;
- 
 
 169 
			}
- 
 
 170 
			return it;
- 
 
 171 
		}
- 
 
 172
- 
 
 173 
		iterator erase(iterator& where)
- 
 
 174 
		{
- 
 
 175 
			if(where==end()) return where;
- 
 
 176 
			iterator src=where + 1;
- 
 
 177 
			iterator dest=where;
- 
 
 178 
			while(src!=end()){
- 
 
 179 
				*dest=*src;
- 
 
 180 
				++dest; ++src;
- 
 
 181 
			}
- 
 
 182 
			m_last--;
- 
 
 183 
			return where;
- 
 
 184 
		}
152 
};
 185 
};
153 
 
 186 
 
154 
}; // namespace ext
 187 
}; // namespace ext
155 
 
 188 
 
156 
#endif // !defined(EXT_ARRAY_INCLUDED)
 189 
#endif // !defined(EXT_ARRAY_INCLUDED)