libptytty/src/estl.h

#ifndef ESTL_H_
#define ESTL_H_

#include <stdlib.h>
#include <string.h>

template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }

template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; }

template <typename I, typename T>
I find (I first, I last, const T& value)
{
  while (first != last && *first != value)
    ++first;

  return first;
}

/* simplevec taken (and heavily modified), from:
 *
 *  MICO --- a free CORBA implementation
 *  Copyright (C) 1997-98 Kay Roemer & Arno Puder
 *  originally GPLv2 or any later
 */
template<class T>
struct simplevec
{
  typedef T *iterator;
  typedef const T *const_iterator;
  typedef unsigned long size_type;

private:
  size_type _last, _size;
  T *_buf;

public:
  const_iterator begin () const { return &_buf[0]; }
  iterator       begin ()       { return &_buf[0]; }

  const_iterator end () const { return &_buf[_last]; }
  iterator       end ()       { return &_buf[_last]; }

  size_type capacity () const { return _size; }
  size_type size     () const { return _last; }

private:
  static T *alloc (size_type n)
  {
    return (T *)::operator new ((size_t) (n * sizeof (T)));
  }

  static void dealloc (T *buf)
  {
    if (buf)
      ::operator delete (buf);
  }

  size_type good_size (size_type n)
  {
    return max (n, _size ? _size * 2 : 5);
  }

  void reserve (iterator where, size_type n)
  {
    if (_last + n <= _size)
      memmove (where + n, where, (end () - where) * sizeof (T));
    else
      {
        size_type sz = _last + n;
        sz = good_size (sz);
        T *nbuf = alloc (sz);

        if (_buf)
          {
            memcpy (nbuf, begin (), (where - begin ()) * sizeof (T));
            memcpy (nbuf + (where - begin ()) + n, where, (end () - where) * sizeof (T));
            dealloc (_buf);
          }

        _buf = nbuf;
        _size = sz;
      }
  }

public:
  void reserve (size_type sz)
  {
    if (_size < sz)
      {
        sz = good_size (sz);
        T *nbuf = alloc (sz);

        if (_buf)
          {
            memcpy (nbuf, begin (), size () * sizeof (T));
            dealloc (_buf);
          }

        _buf = nbuf;
        _size = sz;
      }
  }

  simplevec ()
  : _last(0), _size(0), _buf(0)
  {
  }

  simplevec (size_type n, const T& t = T ())
  : _last(0), _size(0), _buf(0)
  {
    insert (begin (), n, t);
  }

  simplevec (const_iterator first, const_iterator last)
  : _last(0), _size(0), _buf(0)
  {
    insert (begin (), first, last);
  }

  simplevec (const simplevec<T> &v)
  : _last(0), _size(0), _buf(0)
  {
    reserve (v._last);
    memcpy (_buf, v.begin (), v.size () * sizeof (T));
    _last = v._last;
  }

  simplevec<T> &operator= (const simplevec<T> &v)
  {
    if (this != &v)
      {
        _last = 0;
        reserve (v._last);
        memcpy (_buf, v.begin (), v.size () * sizeof (T));
        _last = v._last;
      }

    return *this;
  }

  ~simplevec ()
  {
    dealloc (_buf);
  }

  const T &front () const { return _buf[      0]; }
        T &front ()       { return _buf[      0]; }
  const T &back  () const { return _buf[_last-1]; }
        T &back  ()       { return _buf[_last-1]; }

  bool empty () const
  {
    return _last == 0;
  }

  void clear ()
  {
    _last = 0;
  }

  void push_back (const T &t)
  {
    reserve (_last+1);
    *end () = t;
    ++_last;
  }

  void push_back (T &t)
  {
    reserve (_last+1);
    *end () = t;
    ++_last;
  }

  void pop_back ()
  {
    --_last;
  }

  const T &operator [](size_type idx) const { return _buf[idx]; }
        T &operator [](size_type idx)       { return _buf[idx]; }

  iterator insert (iterator pos, const T &t)
  {
    long at = pos - begin ();
    reserve (pos, 1);
    pos = begin () + at;
    *pos = t;
    ++_last;
    return pos;
  }

  iterator insert (iterator pos, const_iterator first, const_iterator last)
  {
    long n = last - first;
    long at = pos - begin ();

    if (n > 0)
      {
        reserve (pos, n);
        pos = begin () + at;
        memcpy (pos, first, (last - first) * sizeof (T));
        _last += n;
      }

    return pos;
  }

  iterator insert (iterator pos, size_type n, const T &t)
  {
    long at = pos - begin ();

    if (n > 0)
      {
        reserve (pos, n);
        pos = begin () + at;
        for (int i = 0; i < n; ++i)
          pos[i] = t;
        _last += n;
      }

    return pos;
  }

  void erase (iterator first, iterator last)
  {
    if (last != first)
      {
        memmove (first, last, (end () - last) * sizeof (T));
        _last -= last - first;
      }
  }

  void erase (iterator pos)
  {
    if (pos != end ())
      {
        memmove (pos, pos + 1, (end () - (pos + 1)) * sizeof (T));
        --_last;
      }
  }

  void swap (simplevec<T> &t)
  {
    ::swap (_last, t._last);
    ::swap (_size, t._size);
    ::swap (_buf, t._buf);
  }
};

template<class T>
bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)
{
  if (v1.size () != v2.size ()) return false;

  return !v1.size () || !memcmp (&v1[0], &v2[0], v1.size () * sizeof (T));
}

template<class T>
bool operator <(const simplevec<T> &v1, const simplevec<T> &v2)
{
  unsigned long minlast = min (v1.size (), v2.size ());

  for (unsigned long i = 0; i < minlast; ++i)
    {
      if (v1[i] < v2[i]) return true;
      if (v2[i] < v1[i]) return false;
    }
  return v1.size () < v2.size ();
}

template<typename T>
struct vector : simplevec<T>
{
};

#endif

Revision:	1.6
Committed:	Fri Apr 13 11:32:26 2012 UTC (12 years, 2 months ago) by sf-exg
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+1 -1 lines
Log Message:	Fix style.
#	Content
1	#ifndef ESTL_H_
2	#define ESTL_H_
3
4	#include <stdlib.h>
5	#include <string.h>
6
7	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; }
9
10	template<typename T, typename U> static inline void swap (T& a, U& b) { T t = a; a = (T)b; b = (U)t; }
11
12	template <typename I, typename T>
13	I find (I first, I last, const T& value)
14	{
15	while (first != last && *first != value)
16	++first;
17
18	return first;
19	}
20
21	/* simplevec taken (and heavily modified), from:
22	*
23	* MICO --- a free CORBA implementation
24	* Copyright (C) 1997-98 Kay Roemer & Arno Puder
25	* originally GPLv2 or any later
26	*/
27	template<class T>
28	struct simplevec
29	{
30	typedef T *iterator;
31	typedef const T *const_iterator;
32	typedef unsigned long size_type;
33
34	private:
35	size_type _last, _size;
36	T *_buf;
37
38	public:
39	const_iterator begin () const { return &_buf[0]; }
40	iterator begin () { return &_buf[0]; }
41
42	const_iterator end () const { return &_buf[_last]; }
43	iterator end () { return &_buf[_last]; }
44
45	size_type capacity () const { return _size; }
46	size_type size () const { return _last; }
47
48	private:
49	static T *alloc (size_type n)
50	{
51	return (T )::operator new ((size_t) (n sizeof (T)));
52	}
53
54	static void dealloc (T *buf)
55	{
56	if (buf)
57	::operator delete (buf);
58	}
59
60	size_type good_size (size_type n)
61	{
62	return max (n, _size ? _size * 2 : 5);
63	}
64
65	void reserve (iterator where, size_type n)
66	{
67	if (_last + n <= _size)
68	memmove (where + n, where, (end () - where) * sizeof (T));
69	else
70	{
71	size_type sz = _last + n;
72	sz = good_size (sz);
73	T *nbuf = alloc (sz);
74
75	if (_buf)
76	{
77	memcpy (nbuf, begin (), (where - begin ()) * sizeof (T));
78	memcpy (nbuf + (where - begin ()) + n, where, (end () - where) * sizeof (T));
79	dealloc (_buf);
80	}
81
82	_buf = nbuf;
83	_size = sz;
84	}
85	}
86
87	public:
88	void reserve (size_type sz)
89	{
90	if (_size < sz)
91	{
92	sz = good_size (sz);
93	T *nbuf = alloc (sz);
94
95	if (_buf)
96	{
97	memcpy (nbuf, begin (), size () * sizeof (T));
98	dealloc (_buf);
99	}
100
101	_buf = nbuf;
102	_size = sz;
103	}
104	}
105
106	simplevec ()
107	: _last(0), _size(0), _buf(0)
108	{
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
117	simplevec (const_iterator first, const_iterator last)
118	: _last(0), _size(0), _buf(0)
119	{
120	insert (begin (), first, last);
121	}
122
123	simplevec (const simplevec<T> &v)
124	: _last(0), _size(0), _buf(0)
125	{
126	reserve (v._last);
127	memcpy (_buf, v.begin (), v.size () * sizeof (T));
128	_last = v._last;
129	}
130
131	simplevec<T> &operator= (const simplevec<T> &v)
132	{
133	if (this != &v)
134	{
135	_last = 0;
136	reserve (v._last);
137	memcpy (_buf, v.begin (), v.size () * sizeof (T));
138	_last = v._last;
139	}
140
141	return *this;
142	}
143
144	~simplevec ()
145	{
146	dealloc (_buf);
147	}
148
149	const T &front () const { return _buf[ 0]; }
150	T &front () { return _buf[ 0]; }
151	const T &back () const { return _buf[_last-1]; }
152	T &back () { return _buf[_last-1]; }
153
154	bool empty () const
155	{
156	return _last == 0;
157	}
158
159	void clear ()
160	{
161	_last = 0;
162	}
163
164	void push_back (const T &t)
165	{
166	reserve (_last+1);
167	*end () = t;
168	++_last;
169	}
170
171	void push_back (T &t)
172	{
173	reserve (_last+1);
174	*end () = t;
175	++_last;
176	}
177
178	void pop_back ()
179	{
180	--_last;
181	}
182
183	const T &operator [](size_type idx) const { return _buf[idx]; }
184	T &operator [](size_type idx) { return _buf[idx]; }
185
186	iterator insert (iterator pos, const T &t)
187	{
188	long at = pos - begin ();
189	reserve (pos, 1);
190	pos = begin () + at;
191	*pos = t;
192	++_last;
193	return pos;
194	}
195
196	iterator insert (iterator pos, const_iterator first, const_iterator last)
197	{
198	long n = last - first;
199	long at = pos - begin ();
200
201	if (n > 0)
202	{
203	reserve (pos, n);
204	pos = begin () + at;
205	memcpy (pos, first, (last - first) * sizeof (T));
206	_last += n;
207	}
208
209	return pos;
210	}
211
212	iterator insert (iterator pos, size_type n, const T &t)
213	{
214	long at = pos - begin ();
215
216	if (n > 0)
217	{
218	reserve (pos, n);
219	pos = begin () + at;
220	for (int i = 0; i < n; ++i)
221	pos[i] = t;
222	_last += n;
223	}
224
225	return pos;
226	}
227
228	void erase (iterator first, iterator last)
229	{
230	if (last != first)
231	{
232	memmove (first, last, (end () - last) * sizeof (T));
233	_last -= last - first;
234	}
235	}
236
237	void erase (iterator pos)
238	{
239	if (pos != end ())
240	{
241	memmove (pos, pos + 1, (end () - (pos + 1)) * sizeof (T));
242	--_last;
243	}
244	}
245
246	void swap (simplevec<T> &t)
247	{
248	::swap (_last, t._last);
249	::swap (_size, t._size);
250	::swap (_buf, t._buf);
251	}
252	};
253
254	template<class T>
255	bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)
256	{
257	if (v1.size () != v2.size ()) return false;
258
259	return !v1.size () \|\| !memcmp (&v1[0], &v2[0], v1.size () * sizeof (T));
260	}
261
262	template<class T>
263	bool operator <(const simplevec<T> &v1, const simplevec<T> &v2)
264	{
265	unsigned long minlast = min (v1.size (), v2.size ());
266
267	for (unsigned long i = 0; i < minlast; ++i)
268	{
269	if (v1[i] < v2[i]) return true;
270	if (v2[i] < v1[i]) return false;
271	}
272	return v1.size () < v2.size ();
273	}
274
275	template<typename T>
276	struct vector : simplevec<T>
277	{
278	};
279
280	#endif
281