ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/simplevec.h
(Generate patch)

Comparing rxvt-unicode/src/simplevec.h (file contents):
Revision 1.3 by pcg, Sat Jan 31 00:20:21 2004 UTC vs.
Revision 1.4 by pcg, Fri Feb 13 12:16:21 2004 UTC

… …
63 } 63 }
64 64
65private: 65private:
66 static T *alloc (size_type n) 66 static T *alloc (size_type n)
67 { 67 {
68 return (T *)::operator new ((size_t)(n * sizeof (T))); 68 return (T *)::operator new ((size_t) (n * sizeof (T)));
69 } 69 }
70 static void dealloc (T *buf) 70 static void dealloc (T *buf)
71 { 71 {
72 if (buf) 72 if (buf)
73 ::operator delete (buf); 73 ::operator delete (buf);
74 } 74 }
75 75
76 void reserve (iterator where, size_type n) 76 void reserve (iterator where, size_type n)
77 { 77 {
78 if (_last + n <= _size) { 78 if (_last + n <= _size) {
79 memmove (where+n, where, (end()-where)*sizeof(T)); 79 memmove (where+n, where, (end ()-where)*sizeof (T));
80 } else { 80 } else {
81 size_type sz = _last+n; 81 size_type sz = _last+n;
82 sz = (_size == 0) ? max(sz, 5) : max(sz, 2*_size); 82 sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
83 T *nbuf = alloc (sz); 83 T *nbuf = alloc (sz);
84 if (_buf) { 84 if (_buf) {
85 memcpy (nbuf, begin(), (where-begin())*sizeof(T)); 85 memcpy (nbuf, begin (), (where-begin ())*sizeof (T));
86 memcpy (nbuf + (where-begin()) + n, where, 86 memcpy (nbuf + (where-begin ()) + n, where,
87 (end()-where)*sizeof(T)); 87 (end ()-where)*sizeof (T));
88 dealloc (_buf); 88 dealloc (_buf);
89 } 89 }
90 _buf = nbuf; 90 _buf = nbuf;
91 _size = sz; 91 _size = sz;
92 } 92 }
93 } 93 }
94public: 94public:
95 void reserve (size_type sz) 95 void reserve (size_type sz)
96 { 96 {
97 if (_size < sz) { 97 if (_size < sz) {
98 sz = (_size == 0) ? max(sz, 5) : max(sz, 2*_size); 98 sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
99 T *nbuf = alloc (sz); 99 T *nbuf = alloc (sz);
100 if (_buf) { 100 if (_buf) {
101 memcpy (nbuf, begin(), size()*sizeof(T)); 101 memcpy (nbuf, begin (), size ()*sizeof (T));
102 dealloc (_buf); 102 dealloc (_buf);
103 } 103 }
104 _buf = nbuf; 104 _buf = nbuf;
105 _size = sz; 105 _size = sz;
106 } 106 }
107 } 107 }
108 simplevec () 108 simplevec ()
109 : _last (0), _size (0), _buf (0) 109 : _last (0), _size (0), _buf (0)
110 { 110 {
111 } 111 }
112 simplevec (size_type n, const T& t = T()) 112 simplevec (size_type n, const T& t = T ())
113 : _last (0), _size (0), _buf (0) 113 : _last (0), _size (0), _buf (0)
114 { 114 {
115 insert (begin(), n, t); 115 insert (begin (), n, t);
116 } 116 }
117 simplevec (const_iterator first, const_iterator last) 117 simplevec (const_iterator first, const_iterator last)
118 : _last (0), _size (0), _buf (0) 118 : _last (0), _size (0), _buf (0)
119 { 119 {
120 insert (begin(), first, last); 120 insert (begin (), first, last);
121 } 121 }
122 simplevec (const simplevec<T> &v) 122 simplevec (const simplevec<T> &v)
123 : _last (0), _size (0), _buf (0) 123 : _last (0), _size (0), _buf (0)
124 { 124 {
125 reserve (v._last); 125 reserve (v._last);
126 memcpy (_buf, v.begin(), v.size()*sizeof(T)); 126 memcpy (_buf, v.begin (), v.size ()*sizeof (T));
127 _last = v._last; 127 _last = v._last;
128 } 128 }
129 simplevec<T> &operator= (const simplevec<T> &v) 129 simplevec<T> &operator= (const simplevec<T> &v)
130 { 130 {
131 if (this != &v) { 131 if (this != &v) {
132 _last = 0; 132 _last = 0;
133 reserve (v._last); 133 reserve (v._last);
134 memcpy (_buf, v.begin(), v.size()*sizeof(T)); 134 memcpy (_buf, v.begin (), v.size ()*sizeof (T));
135 _last = v._last; 135 _last = v._last;
136 } 136 }
137 return *this; 137 return *this;
138 } 138 }
139 ~simplevec () 139 ~simplevec ()
140 { 140 {
141 dealloc (_buf); 141 dealloc (_buf);
142 } 142 }
143 const T &front () const 143 const T &front () const
144 { 144 {
145 //ministl_assert (size() > 0); 145 //ministl_assert (size () > 0);
146 return _buf[0]; 146 return _buf[0];
147 } 147 }
148 T &front () 148 T &front ()
149 { 149 {
150 //ministl_assert (size() > 0); 150 //ministl_assert (size () > 0);
151 return _buf[0]; 151 return _buf[0];
152 } 152 }
153 const T &back () const 153 const T &back () const
154 { 154 {
155 //ministl_assert (size() > 0); 155 //ministl_assert (size () > 0);
156 return _buf[_last-1]; 156 return _buf[_last-1];
157 } 157 }
158 T &back () 158 T &back ()
159 { 159 {
160 //ministl_assert (size() > 0); 160 //ministl_assert (size () > 0);
161 return _buf[_last-1]; 161 return _buf[_last-1];
162 } 162 }
163 bool empty () const 163 bool empty () const
164 { 164 {
165 return _last == 0; 165 return _last == 0;
… …
169 _last = 0; 169 _last = 0;
170 } 170 }
171 void push_back (const T &t) 171 void push_back (const T &t)
172 { 172 {
173 reserve (_last+1); 173 reserve (_last+1);
174 *end() = t; 174 *end () = t;
175 ++_last; 175 ++_last;
176 } 176 }
177 void push_back (T &t) 177 void push_back (T &t)
178 { 178 {
179 reserve (_last+1); 179 reserve (_last+1);
180 *end() = t; 180 *end () = t;
181 ++_last; 181 ++_last;
182 } 182 }
183 void pop_back () 183 void pop_back ()
184 { 184 {
185 //ministl_assert (size() > 0); 185 //ministl_assert (size () > 0);
186 --_last; 186 --_last;
187 } 187 }
188 const T &operator[] (size_type idx) const 188 const T &operator[] (size_type idx) const
189 { 189 {
190 //ministl_assert (idx < size()); 190 //ministl_assert (idx < size ());
191 return _buf[idx]; 191 return _buf[idx];
192 } 192 }
193 T &operator[] (size_type idx) 193 T &operator[] (size_type idx)
194 { 194 {
195 //ministl_assert (idx < size()); 195 //ministl_assert (idx < size ());
196 return _buf[idx]; 196 return _buf[idx];
197 } 197 }
198 iterator insert (iterator pos, const T &t) 198 iterator insert (iterator pos, const T &t)
199 { 199 {
200 //ministl_assert (pos <= end()); 200 //ministl_assert (pos <= end ());
201 long at = pos - begin(); 201 long at = pos - begin ();
202 reserve (pos, 1); 202 reserve (pos, 1);
203 pos = begin()+at; 203 pos = begin ()+at;
204 *pos = t; 204 *pos = t;
205 ++_last; 205 ++_last;
206 return pos; 206 return pos;
207 } 207 }
208 iterator insert (iterator pos, const_iterator first, const_iterator last) 208 iterator insert (iterator pos, const_iterator first, const_iterator last)
209 { 209 {
210 //ministl_assert (pos <= end()); 210 //ministl_assert (pos <= end ());
211 long n = last - first; 211 long n = last - first;
212 long at = pos - begin(); 212 long at = pos - begin ();
213 if (n > 0) { 213 if (n > 0) {
214 reserve (pos, n); 214 reserve (pos, n);
215 pos = begin()+at; 215 pos = begin ()+at;
216 memcpy (pos, first, (last-first)*sizeof(T)); 216 memcpy (pos, first, (last-first)*sizeof (T));
217 _last += n; 217 _last += n;
218 } 218 }
219 return pos; 219 return pos;
220 } 220 }
221 iterator insert (iterator pos, size_type n, const T &t) 221 iterator insert (iterator pos, size_type n, const T &t)
222 { 222 {
223 //ministl_assert (pos <= end()); 223 //ministl_assert (pos <= end ());
224 long at = pos - begin(); 224 long at = pos - begin ();
225 if (n > 0) { 225 if (n > 0) {
226 reserve (pos, n); 226 reserve (pos, n);
227 pos = begin()+at; 227 pos = begin ()+at;
228 for (int i = 0; i < n; ++i) 228 for (int i = 0; i < n; ++i)
229 pos[i] = t; 229 pos[i] = t;
230 _last += n; 230 _last += n;
231 } 231 }
232 return pos; 232 return pos;
233 } 233 }
234 void erase (iterator first, iterator last) 234 void erase (iterator first, iterator last)
235 { 235 {
236 if (last != first) { 236 if (last != first) {
237 memmove (first, last, (end()-last)*sizeof(T)); 237 memmove (first, last, (end ()-last)*sizeof (T));
238 _last -= last - first; 238 _last -= last - first;
239 } 239 }
240 } 240 }
241 void erase (iterator pos) 241 void erase (iterator pos)
242 { 242 {
243 if (pos != end()) { 243 if (pos != end ()) {
244 memmove (pos, pos+1, (end()-(pos+1))*sizeof(T)); 244 memmove (pos, pos+1, (end ()- (pos+1))*sizeof (T));
245 --_last; 245 --_last;
246 } 246 }
247 } 247 }
248}; 248};
249 249
250template<class T> 250template<class T>
251bool operator== (const simplevec<T> &v1, const simplevec<T> &v2) 251bool operator== (const simplevec<T> &v1, const simplevec<T> &v2)
252{ 252{
253 if (v1.size() != v2.size()) 253 if (v1.size () != v2.size ())
254 return false; 254 return false;
255 return !v1.size() || !memcmp (&v1[0], &v2[0], v1.size()*sizeof(T)); 255 return !v1.size () || !memcmp (&v1[0], &v2[0], v1.size ()*sizeof (T));
256} 256}
257 257
258template<class T> 258template<class T>
259bool operator< (const simplevec<T> &v1, const simplevec<T> &v2) 259bool operator< (const simplevec<T> &v1, const simplevec<T> &v2)
260{ 260{
261 unsigned long minlast = min (v1.size(), v2.size()); 261 unsigned long minlast = min (v1.size (), v2.size ());
262 for (unsigned long i = 0; i < minlast; ++i) { 262 for (unsigned long i = 0; i < minlast; ++i) {
263 if (v1[i] < v2[i]) 263 if (v1[i] < v2[i])
264 return true; 264 return true;
265 if (v2[i] < v1[i]) 265 if (v2[i] < v1[i])
266 return false; 266 return false;
267 } 267 }
268 return v1.size() < v2.size(); 268 return v1.size () < v2.size ();
269} 269}
270 270
271#endif 271#endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines