rxvt-unicode/src/rxvtstl.h

#ifndef RXVT_STL_H
#define RXVT_STL_H

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

#include "simplevec.h"

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

#if 0
template<typename T>
struct rxvt_vec : simplevec<void *> {
  typedef T *iterator;

  void push_back (T d) { simplevec<void *>::push_back ((void *)d); }
  T pop_back () { return (T*)simplevec<void *>::pop_back (); }
  void erase (int i) { erase (begin () + i); }
  void erase (iterator i) { simplevec<void *>::erase ((void **)i); }
  iterator begin () const { return (iterator)simplevec<void *>::begin (); }
  iterator end () const { return (iterator)simplevec<void *>::end (); }
  T &operator [] (int i) { return * (T *) (& ((* (simplevec<void *> *)this)[i])); }
  const T &operator [] (int i) const { return * (const T *) (& ((* (const simplevec<void *> *)this)[i])); }
};
#endif

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

  return first;
}

template<typename T>
struct auto_ptr {
  T *p;

  auto_ptr () : p (0) { }
  auto_ptr (T *a) : p (a) { }

  auto_ptr (auto_ptr<T> &a)
  {
    p = a.p;
    a.p = 0;
  }

  template<typename A>
  auto_ptr (auto_ptr<A> &a)
  {
    p = a.p;
    a.p = 0;
  }

  ~auto_ptr ()
  {
    delete p;
  }

  // void because it makes sense in our context
  void operator = (T *a)
  {
    delete p;
    p = a;
  }

  void operator = (auto_ptr &a)
  {
    *this = a.p;
    a.p = 0;
  }

  template<typename A>
  void operator = (auto_ptr<A> &a)
  {
    *this = a.p;
    a.p = 0;
  }

  operator T * () const { return p; }

  T *operator -> () const { return p; }
  T &operator * () const { return *p; }

  T *get ()
  {
    T *r = p;
    p = 0;
    return r;
  }
};

typedef auto_ptr<char> auto_str;

struct stringvec : simplevec<char *>
{
  ~stringvec ()
  {
    for (char **c = begin (); c != end (); c++)
      delete [] *c;
  }
};

#endif

Revision:	1.4
Committed:	Fri Feb 13 12:16:21 2004 UTC (20 years, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1_9, rel-3_6, rel-3_5, rel-3_4, rel-3_3, rel-3_2, rel-2_8, rel-3_0, rel-2_7, rel-2_4, rel-2_5, rel-2_2, rel-2_3, rel-2_0, rxvt-2-0, rel-1-9, rel-2_1_0
Changes since 1.3:	+15 -15 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	#ifndef RXVT_STL_H
2			#define RXVT_STL_H
3
4	pcg	1.2	template<typename T, typename U> static inline T min (T a, U b) { return a < b ? a : b; }
5			template<typename T, typename U> static inline T max (T a, U b) { return a > b ? a : b; }
6	pcg	1.1
7			#include "simplevec.h"
8
9			template<typename T>
10			struct vector : simplevec<T>
11	pcg	1.3	{ };
12	pcg	1.1
13			#if 0
14			template<typename T>
15			struct rxvt_vec : simplevec<void *> {
16			typedef T *iterator;
17
18			void push_back (T d) { simplevec<void >::push_back ((void )d); }
19			T pop_back () { return (T)simplevec<void >::pop_back (); }
20			void erase (int i) { erase (begin () + i); }
21			void erase (iterator i) { simplevec<void >::erase ((void *)i); }
22			iterator begin () const { return (iterator)simplevec<void *>::begin (); }
23			iterator end () const { return (iterator)simplevec<void *>::end (); }
24	pcg	1.4	T &operator [] (int i) { return * (T ) (& (( (simplevec<void > )this)[i])); }
25			const T &operator [] (int i) const { return * (const T ) (& (( (const simplevec<void > )this)[i])); }
26	pcg	1.1	};
27			#endif
28
29			template <typename I, typename T>
30	pcg	1.4	I find (I first, I last, const T& value)
31	pcg	1.1	{
32			while (first != last && *first != value)
33			++first;
34
35			return first;
36			}
37
38			template<typename T>
39			struct auto_ptr {
40			T *p;
41
42	pcg	1.4	auto_ptr () : p (0) { }
43			auto_ptr (T *a) : p (a) { }
44	pcg	1.1
45	pcg	1.4	auto_ptr (auto_ptr<T> &a)
46	pcg	1.1	{
47			p = a.p;
48			a.p = 0;
49			}
50
51			template<typename A>
52	pcg	1.4	auto_ptr (auto_ptr<A> &a)
53	pcg	1.1	{
54			p = a.p;
55			a.p = 0;
56			}
57
58	pcg	1.4	~auto_ptr ()
59	pcg	1.1	{
60			delete p;
61			}
62
63			// void because it makes sense in our context
64	pcg	1.4	void operator = (T *a)
65	pcg	1.1	{
66			delete p;
67			p = a;
68			}
69
70	pcg	1.4	void operator = (auto_ptr &a)
71	pcg	1.1	{
72			*this = a.p;
73			a.p = 0;
74			}
75
76			template<typename A>
77	pcg	1.4	void operator = (auto_ptr<A> &a)
78	pcg	1.1	{
79			*this = a.p;
80			a.p = 0;
81			}
82
83	pcg	1.4	operator T * () const { return p; }
84	pcg	1.1
85	pcg	1.4	T *operator -> () const { return p; }
86			T &operator * () const { return *p; }
87	pcg	1.1
88			T *get ()
89			{
90			T *r = p;
91			p = 0;
92			return r;
93			}
94			};
95
96			typedef auto_ptr<char> auto_str;
97
98			struct stringvec : simplevec<char *>
99			{
100			~stringvec ()
101			{
102	pcg	1.4	for (char **c = begin (); c != end (); c++)
103	pcg	1.1	delete [] *c;
104			}
105			};
106
107			#endif
108