[ViewVC] Diff of: cvs/libptytty/src/estl.h

Comparing libptytty/src/estl.h (file contents):
Revision 1.2 by sf-exg, Sat Jan 21 13:44:38 2012 UTC vs.
Revision 1.28 by sf-exg, Mon Nov 10 11:32:00 2014 UTC

1	#ifndef ESTL_H	1	#ifndef ESTL_H_
2	#define ESTL_H	2	#define ESTL_H_
3		3
4	#include <stdlib.h>	4	#include <stdlib.h>
5	#include <string.h>	5	#include <string.h>
6		6
		7	#include "ecb.h"
		8
7	template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }	9	template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
8	template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }	10	template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
9		11
10	template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }	12	template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; }
11		13
12	template <typename I, typename T>	14	template <typename I, typename T>
13	I find (I first, I last, const T& value)	15	I find (I first, I last, const T& value)
14	{	16	{
15	while (first != last && *first != value)	17	while (first != last && *first != value)
16	++first;	18	++first;
17		19
18	return first;	20	return first;
19	}	21	}
20		22
21	/* simplevec taken (and heavily modified), from:	23	#include <new>
22	*	24
23	* MICO --- a free CORBA implementation	25	#if ECB_CPP11
24	* Copyright (C) 1997-98 Kay Roemer & Arno Puder	26	#include <type_traits>
25	*/	27	#endif
		28
		29	namespace estl
		30	{
		31	#if ESTL_LARGE_MEMORY_MODEL
		32	// should use size_t/ssize_t, but that's not portable enough for us
		33	typedef unsigned long size_type;
		34	typedef long difference_type;
		35	#else
		36	typedef uint32_t size_type;
		37	typedef int32_t difference_type;
		38	#endif
		39
		40	template<typename T>
		41	struct scoped_ptr
		42	{
		43	T *p;
		44
		45	scoped_ptr () : p (0) { }
		46
		47	explicit
		48	scoped_ptr (T *a) : p (a) { }
		49
		50	~scoped_ptr ()
		51	{
		52	delete p;
		53	}
		54
		55	void reset (T *a)
		56	{
		57	delete p;
		58	p = a;
		59	}
		60
		61	T *operator ->() const { return p; }
		62	T &operator () const { return p; }
		63
		64	operator T *() { return p; }
		65	T *get () const { return p; }
		66	};
		67
		68	template<typename T>
		69	struct scoped_array
		70	{
		71	T *p;
		72
		73	scoped_array () : p (0) { }
		74
		75	explicit
		76	scoped_array (T *a) : p (a) { }
		77
		78	~scoped_array ()
		79	{
		80	delete [] p;
		81	}
		82
		83	void reset (T *a)
		84	{
		85	delete [] p;
		86	p = a;
		87	}
		88
		89	T & operator [](size_type idx) const { return p[idx]; }
		90
		91	operator T *() { return p; }
		92	T *get () const { return p; }
		93	};
		94	}
		95
		96	// original version taken from MICO, but this has been completely rewritten
		97	// known limitations w.r.t. std::vector
		98	// - many methods missing
		99	// - no error checking, no exceptions thrown (e.g. at())
		100	// - size_type is 32bit even on 64 bit hosts, so limited to 2**31 elements
		101	// - no allocator support
		102	// - we don't really care about const correctness, but we try
		103	// - we don't care about namespaces and stupid macros the user might define
		104	// - no bool specialisation
26	template<class T>	105	template<class T>
27	struct simplevec	106	struct simplevec
28	{	107	{
		108	typedef estl::size_type size_type;
		109
		110	typedef T value_type;
29	typedef T* iterator;	111	typedef T *iterator;
30	typedef const T* const_iterator;	112	typedef const T *const_iterator;
31	typedef unsigned long size_type;	113	typedef T *pointer;
		114	typedef const T *const_pointer;
		115	typedef T &reference;
		116	typedef const T &const_reference;
		117	// missing: allocator_type
		118	// missing: reverse iterator
32		119
33	private:	120	private:
34	size_type _last, _size;	121	size_type sze, res;
35	T *_buf;	122	T *buf;
		123
		124	// we shamelessly optimise for "simple" types. everything
		125	// "not simple enough" will use the slow path.
		126	static bool is_simple_enough ()
		127	{
		128	#if ECB_CPP11
		129	return std::is_trivially_assignable<T, T>::value
		130	&& std::is_trivially_constructible<T>::value
		131	&& std::is_trivially_copyable<T>::value
		132	&& std::is_trivially_destructible<T>::value;
		133	#elif ECB_GCC_VERSION(4,4) \|\| ECB_CLANG_VERSION(2,8)
		134	return __has_trivial_assign (T)
		135	&& __has_trivial_constructor (T)
		136	&& __has_trivial_copy (T)
		137	&& __has_trivial_destructor (T);
		138	#else
		139	return 0;
		140	#endif
		141	}
		142
		143	static void construct (iterator a, size_type n = 1)
		144	{
		145	if (!is_simple_enough ())
		146	while (n--)
		147	new (a++) T ();
		148	}
		149
		150	static void destruct (iterator a, size_type n = 1)
		151	{
		152	if (!is_simple_enough ())
		153	while (n--)
		154	(*a++).~T ();
		155	}
		156
		157	template<class I>
		158	static void cop_new (iterator a, I b) { new (a) T (*b); }
		159	template<class I>
		160	static void cop_set (iterator a, I b) { a = b ; }
		161
		162	// MUST copy forwards
		163	template<class I>
		164	static void copy (iterator dst, I src, size_type n, void (*op)(iterator, I))
		165	{
		166	while (n--)
		167	op (dst++, src++);
		168	}
		169
		170	static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator))
		171	{
		172	if (is_simple_enough ())
		173	memcpy (dst, src, sizeof (T) * n);
		174	else
		175	copy<iterator> (dst, src, n, op);
		176	}
		177
		178	static T *alloc (size_type n) ecb_cold
		179	{
		180	return (T )::operator new ((size_t) (sizeof (T) n));
		181	}
		182
		183	void dealloc () ecb_cold
		184	{
		185	destruct (buf, sze);
		186	::operator delete (buf);
		187	}
		188
		189	size_type good_size (size_type n) ecb_cold
		190	{
		191	return n ? 2UL << ecb_ld32 (n) : 5;
		192	}
		193
		194	void ins (iterator where, size_type n)
		195	{
		196	size_type pos = where - begin ();
		197
		198	if (ecb_expect_false (sze + n > res))
		199	{
		200	res = good_size (sze + n);
		201
		202	T *nbuf = alloc (res);
		203	copy (nbuf, buf, sze, cop_new);
		204	dealloc ();
		205	buf = nbuf;
		206	}
		207
		208	construct (buf + sze, n);
		209
		210	iterator src = buf + pos;
		211	if (is_simple_enough ())
		212	memmove (src + n, src, sizeof (T) * (sze - pos));
		213	else
		214	for (size_type i = sze - pos; i--; )
		215	cop_set (src + n + i, src + i);
		216
		217	sze += n;
		218	}
36		219
37	public:	220	public:
38	const_iterator begin () const	221	size_type capacity () const { return res; }
		222	size_type size () const { return sze; }
		223	bool empty () const { return size () == 0; }
		224
		225	size_t max_size () const
		226	{
		227	return (~(size_type)0) >> 1;
		228	}
		229
		230	const_iterator begin () const { return &buf [ 0]; }
		231	iterator begin () { return &buf [ 0]; }
		232	const_iterator end () const { return &buf [sze ]; }
		233	iterator end () { return &buf [sze ]; }
		234	const_reference front () const { return buf [ 0]; }
		235	reference front () { return buf [ 0]; }
		236	const_reference back () const { return buf [sze - 1]; }
		237	reference back () { return buf [sze - 1]; }
		238
		239	void reserve (size_type sz)
		240	{
		241	if (ecb_expect_true (sz <= res))
		242	return;
		243
		244	sz = good_size (sz);
		245	T *nbuf = alloc (sz);
		246
		247	copy (nbuf, begin (), sze, cop_new);
		248	dealloc ();
		249
		250	buf = nbuf;
		251	res = sz;
		252	}
		253
		254	void resize (size_type sz)
		255	{
		256	reserve (sz);
		257
		258	if (is_simple_enough ())
		259	sze = sz;
		260	else
		261	{
		262	while (sze < sz) construct (buf + sze++);
		263	while (sze > sz) destruct (buf + --sze);
		264	}
		265	}
		266
		267	simplevec ()
		268	: sze(0), res(0), buf(0)
		269	{
		270	}
		271
		272	simplevec (size_type n, const T &t = T ())
		273	{
		274	sze = res = n;
		275	buf = alloc (sze);
		276
		277	while (n--)
		278	new (buf + n) T (t);
		279	}
		280
		281	simplevec (const_iterator first, const_iterator last)
		282	{
		283	sze = res = last - first;
		284	buf = alloc (sze);
		285	copy (buf, first, sze, cop_new);
		286	}
		287
		288	simplevec (const simplevec<T> &v)
		289	: sze(0), res(0), buf(0)
		290	{
		291	sze = res = v.size ();
		292	buf = alloc (sze);
		293	copy (buf, v.begin (), sze, cop_new);
		294	}
		295
		296	~simplevec ()
		297	{
		298	dealloc ();
		299	}
		300
		301	void swap (simplevec<T> &t)
		302	{
		303	::swap (sze, t.sze);
		304	::swap (res, t.res);
		305	::swap (buf, t.buf);
		306	}
		307
		308	void clear ()
		309	{
		310	destruct (buf, sze);
		311	sze = 0;
		312	}
		313
		314	void push_back (const T &t)
		315	{
		316	reserve (sze + 1);
		317	new (buf + sze++) T (t);
		318	}
		319
		320	void pop_back ()
		321	{
		322	destruct (buf + --sze);
		323	}
		324
		325	const_reference operator [](size_type idx) const { return buf[idx]; }
		326	reference operator [](size_type idx) { return buf[idx]; }
		327
		328	const_reference at (size_type idx) const { return buf [idx]; }
		329	reference at (size_type idx) { return buf [idx]; }
		330
		331	void assign (const_iterator first, const_iterator last)
		332	{
		333	simplevec<T> v (first, last);
		334	swap (v);
		335	}
		336
		337	void assign (size_type n, const T &t)
		338	{
		339	simplevec<T> v (n, t);
		340	swap (v);
		341	}
		342
		343	simplevec<T> &operator= (const simplevec<T> &v)
		344	{
		345	assign (v.begin (), v.end ());
		346	return *this;
		347	}
		348
		349	iterator insert (iterator pos, const T &t)
		350	{
		351	size_type at = pos - begin ();
		352
		353	ins (pos, 1);
		354	buf [at] = t;
		355
		356	return buf + at;
		357	}
		358
		359	iterator insert (iterator pos, const_iterator first, const_iterator last)
		360	{
		361	size_type n = last - first;
		362	size_type at = pos - begin ();
		363
		364	ins (pos, n);
		365	copy (buf + at, first, n, cop_set);
		366
		367	return buf + at;
		368	}
		369
		370	iterator insert (iterator pos, size_type n, const T &t)
		371	{
		372	size_type at = pos - begin ();
		373
		374	ins (pos, n);
		375
		376	for (iterator i = buf + at; n--; )
		377	*i++ = t;
		378
		379	return buf + at;
		380	}
		381
		382	iterator erase (iterator first, iterator last)
		383	{
		384	size_type n = last - first;
		385	size_type c = end () - last;
		386
		387	if (is_simple_enough ())
		388	memmove (first, last, sizeof (T) * c);
		389	else
		390	copy (first, last, c, cop_set);
		391
		392	sze -= n;
		393	destruct (buf + sze, n);
		394
		395	return first;
		396	}
		397
		398	iterator erase (iterator pos)
		399	{
		400	if (pos != end ())
		401	erase (pos, pos + 1);
		402
		403	return pos;
		404	}
		405	};
		406
		407	template<class T>
		408	bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)
		409	{
		410	if (v1.size () != v2.size ()) return false;
		411
		412	return !v1.size () \|\| !memcmp (&v1[0], &v2[0], v1.size () * sizeof (T));
		413	}
		414
		415	template<class T>
		416	bool operator <(const simplevec<T> &v1, const simplevec<T> &v2)
		417	{
		418	unsigned long minlast = min (v1.size (), v2.size ());
		419
		420	for (unsigned long i = 0; i < minlast; ++i)
39	{	421	{
40	return &_buf[0];	422	if (v1[i] < v2[i]) return true;
		423	if (v2[i] < v1[i]) return false;
41	}	424	}
42	iterator begin ()
43	{
44	return &_buf[0];
45	}
46	const_iterator end () const
47	{
48	return &_buf[_last];
49	}
50	iterator end ()
51	{
52	return &_buf[_last];
53	}
54	size_type capacity () const
55	{
56	return _size;
57	}
58	size_type size () const
59	{
60	return _last;
61	}
62
63	private:
64	static T *alloc (size_type n)
65	{
66	return (T )::operator new ((size_t) (n sizeof (T)));
67	}
68	static void dealloc (T *buf)
69	{
70	if (buf)
71	::operator delete (buf);
72	}
73
74	void reserve (iterator where, size_type n)
75	{
76	if (_last + n <= _size) {
77	memmove (where+n, where, (end ()-where)*sizeof (T));
78	} else {
79	size_type sz = _last+n;
80	sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
81	T *nbuf = alloc (sz);
82	if (_buf) {
83	memcpy (nbuf, begin (), (where-begin ())*sizeof (T));
84	memcpy (nbuf + (where-begin ()) + n, where,
85	(end ()-where)*sizeof (T));
86	dealloc (_buf);
87	}
88	_buf = nbuf;
89	_size = sz;
90	}
91	}
92
93	public:
94	void reserve (size_type sz)
95	{
96	if (_size < sz) {
97	sz = (_size == 0) ? max (sz, 5) : max (sz, 2*_size);
98	T *nbuf = alloc (sz);
99	if (_buf) {
100	memcpy (nbuf, begin (), size ()*sizeof (T));
101	dealloc (_buf);
102	}
103	_buf = nbuf;
104	_size = sz;
105	}
106	}
107	simplevec ()
108	: _last(0), _size(0), _buf(0)
109	{
110	}
111	simplevec (size_type n, const T& t = T ())
112	: _last(0), _size(0), _buf(0)
113	{
114	insert (begin (), n, t);
115	}
116	simplevec (const_iterator first, const_iterator last)
117	: _last(0), _size(0), _buf(0)
118	{
119	insert (begin (), first, last);
120	}
121	simplevec (const simplevec<T> &v)
122	: _last(0), _size(0), _buf(0)
123	{
124	reserve (v._last);
125	memcpy (_buf, v.begin (), v.size ()*sizeof (T));
126	_last = v._last;
127	}
128	simplevec<T> &operator= (const simplevec<T> &v)
129	{
130	if (this != &v) {
131	_last = 0;
132	reserve (v._last);
133	memcpy (_buf, v.begin (), v.size ()*sizeof (T));
134	_last = v._last;
135	}
136	return *this;
137	}
138	~simplevec ()
139	{
140	dealloc (_buf);
141	}
142	const T &front () const
143	{
144	//ministl_assert (size () > 0);
145	return _buf[0];
146	}
147	T &front ()
148	{
149	//ministl_assert (size () > 0);
150	return _buf[0];
151	}
152	const T &back () const
153	{
154	//ministl_assert (size () > 0);
155	return _buf[_last-1];
156	}
157	T &back ()
158	{
159	//ministl_assert (size () > 0);
160	return _buf[_last-1];
161	}
162	bool empty () const
163	{
164	return _last == 0;
165	}
166	void clear ()
167	{
168	_last = 0;
169	}
170	void push_back (const T &t)
171	{
172	reserve (_last+1);
173	*end () = t;
174	++_last;
175	}
176	void push_back (T &t)
177	{
178	reserve (_last+1);
179	*end () = t;
180	++_last;
181	}
182	void pop_back ()
183	{
184	//ministl_assert (size () > 0);
185	--_last;
186	}
187	const T &operator[] (size_type idx) const
188	{
189	//ministl_assert (idx < size ());
190	return _buf[idx];
191	}
192	T &operator[] (size_type idx)
193	{
194	//ministl_assert (idx < size ());
195	return _buf[idx];
196	}
197	iterator insert (iterator pos, const T &t)
198	{
199	//ministl_assert (pos <= end ());
200	long at = pos - begin ();
201	reserve (pos, 1);
202	pos = begin ()+at;
203	*pos = t;
204	++_last;
205	return pos;
206	}
207	iterator insert (iterator pos, const_iterator first, const_iterator last)
208	{
209	//ministl_assert (pos <= end ());
210	long n = last - first;
211	long at = pos - begin ();
212	if (n > 0) {
213	reserve (pos, n);
214	pos = begin ()+at;
215	memcpy (pos, first, (last-first)*sizeof (T));
216	_last += n;
217	}
218	return pos;
219	}
220	iterator insert (iterator pos, size_type n, const T &t)
221	{
222	//ministl_assert (pos <= end ());
223	long at = pos - begin ();
224	if (n > 0) {
225	reserve (pos, n);
226	pos = begin ()+at;
227	for (int i = 0; i < n; ++i)
228	pos[i] = t;
229	_last += n;
230	}
231	return pos;
232	}
233	void erase (iterator first, iterator last)
234	{
235	if (last != first) {
236	memmove (first, last, (end () - last) * sizeof (T));
237	_last -= last - first;
238	}
239	}
240	void erase (iterator pos)
241	{
242	if (pos != end ()) {
243	memmove (pos, pos+1, (end () - (pos+1)) * sizeof (T));
244	--_last;
245	}
246	}
247	void swap (simplevec<T> &t)
248	{
249	::swap(_last, t._last);
250	::swap(_size, t._size);
251	::swap(_buf, t._buf);
252	}
253	};
254
255	template<class T>
256	bool operator== (const simplevec<T> &v1, const simplevec<T> &v2)
257	{
258	if (v1.size () != v2.size ())
259	return false;
260	return !v1.size () \|\| !memcmp (&v1[0], &v2[0], v1.size ()*sizeof (T));
261	}
262
263	template<class T>
264	bool operator< (const simplevec<T> &v1, const simplevec<T> &v2)
265	{
266	unsigned long minlast = min (v1.size (), v2.size ());
267	for (unsigned long i = 0; i < minlast; ++i) {
268	if (v1[i] < v2[i])
269	return true;
270	if (v2[i] < v1[i])
271	return false;
272	}
273	return v1.size () < v2.size ();	425	return v1.size () < v2.size ();
274	}	426	}
275		427
276	template<typename T>	428	template<typename T>
277	struct vector : simplevec<T>	429	struct vector : simplevec<T>
278	{	430	{
279	};	431	};
280		432
281	#endif	433	#endif
		434

Diff Legend

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

Comparing libptytty/src/estl.h (file contents): Revision 1.2 by sf-exg, Sat Jan 21 13:44:38 2012 UTC vs. Revision 1.28 by sf-exg, Mon Nov 10 11:32:00 2014 UTC

Diff Legend

Comparing libptytty/src/estl.h (file contents):
Revision 1.2 by sf-exg, Sat Jan 21 13:44:38 2012 UTC vs.
Revision 1.28 by sf-exg, Mon Nov 10 11:32:00 2014 UTC