kpx_cpu/include/nvmemfun.hpp

/*
 *  nvmemfun.hpp - Non-virtual member function wrappers
 *
 *  Kheperix (C) 2003 Gwenole Beauchesne
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef NVMEMFUN_H
#define NVMEMFUN_H

#include <functional>

#if defined __GNUC__
#define HAVE_FAST_NV_MEM_FUN 1
#define MEM_FUN_WORDS  2
#if defined __GXX_ABI_VERSION /* GCC >= 3.0 */
#define MEM_FUN_OFFSET 0
#else
#define MEM_FUN_OFFSET 1
#endif
#endif

#if defined __ICC
#define HAVE_FAST_NV_MEM_FUN 1
#define MEM_FUN_WORDS  2
#define MEM_FUN_OFFSET 0 /* GNU C++ ABI v3 */
#endif

#if defined __EDG__  && defined __sgi
#define HAVE_FAST_NV_MEM_FUN 1
#define MEM_FUN_WORDS  3
#define MEM_FUN_OFFSET 2
#endif

#if HAVE_FAST_NV_MEM_FUN

template< class PMF, class PF >
inline PF nv_mem_fun_of(PMF pmf) {
        if (pmf == 0)
                return 0;
        union { PMF pmf; uintptr p[MEM_FUN_WORDS]; } x;
        x.pmf = pmf;
        return (PF)x.p[MEM_FUN_OFFSET];
}

template< class R, class T >
class nv_mem_fun_t : public std::unary_function<T, R> {
        typedef R (T::*pmf_t)();
        typedef R (*pf_t)(T *);
        pf_t pf;
public:
        nv_mem_fun_t(pmf_t pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
        R operator()(T *p) const { return (*pf)(p); }
        pf_t ptr() const { return pf; }
};

template< class R, class T >
class const_nv_mem_fun_t : public std::unary_function<T, R> {
        typedef R (T::*pmf_t)();
        typedef R (*pf_t)(T *);
        pf_t const pf;
public:
        const_nv_mem_fun_t(pmf_t const pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
        R operator()(const T *p) const { return (*pf)(p); }
        pf_t ptr() const { return pf; }
};

template< class R, class T, class A >
class nv_mem_fun1_t : public std::binary_function<T, A, R> {
        typedef R (T::*pmf_t)(A);
        typedef R (*pf_t)(T *, A x);
        pf_t pf;
public:
        nv_mem_fun1_t(pmf_t pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
        R operator()(T *p, A x) const { return (*pf)(p, x); }
        pf_t ptr() const { return pf; }
};

template< class R, class T, class A >
class const_nv_mem_fun1_t : public std::binary_function<T, A, R> {
        typedef R (T::*pmf_t)(A);
        typedef R (*pf_t)(T *, A x);
        pf_t const pf;
public:
        const_nv_mem_fun1_t(pmf_t const pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
        R operator()(const T *p, A x) const { return (*pf)(p, x); }
        pf_t ptr() const { return pf; }
};

#else

template< class R, class T >
class nv_mem_fun_t : public std::unary_function<T, R> {
        typedef R (T::*pmf_t)();
        pmf_t pf;
public:
        nv_mem_fun_t(R (T::*pmf)()) : pf(pmf) {}
        R operator()(T *p) const { return (p->*pf)(); }
        pmf_t ptr() const { return pf; }
};

template< class R, class T >
class const_nv_mem_fun_t : public std::unary_function<T, R> {
        typedef R (T::*pmf_t)() const;
        pmf_t pf;
public:
        const_nv_mem_fun_t(R (T::*pmf)() const) : pf(pmf) {}
        R operator()(const T *p) const { return (p->*pf)(); }
        pmf_t ptr() const { return pf; }
};

template< class R, class T, class A >
class nv_mem_fun1_t : public std::binary_function<T, A, R> {
        typedef R (T::*pmf_t)(A);
        pmf_t pf;
public:
        nv_mem_fun1_t(R (T::*pmf)(A)) : pf(pmf) {}
        R operator()(T *p, A x) const { return (p->*pf)(x); }
        pmf_t ptr() const { return pf; }
};

template< class R, class T, class A >
class const_nv_mem_fun1_t : public std::binary_function<T, A, R> {
        typedef R (T::*pmf_t)(A) const;
        pmf_t pf;
public:
        const_nv_mem_fun1_t(R (T::*pmf)(A) const) : pf(pmf) {}
        R operator()(const T *p, A x) const { return (p->*pf)(x); }
        pmf_t ptr() const { return pf; }
};

#endif

template< class R, class T >
inline nv_mem_fun_t<R, T> nv_mem_fun(R (T::*pmf)()) {
        return nv_mem_fun_t<R, T>(pmf);
}

template< class R, class T >
inline const_nv_mem_fun_t<R, T> nv_mem_fun(R (T::*pmf)() const) {
        return const_nv_mem_fun_t<R, T>(pmf);
}

template< class R, class T, class A >
inline nv_mem_fun1_t<R, T, A> nv_mem_fun(R (T::*pmf)(A)) {
        return nv_mem_fun1_t<R, T, A>(pmf);
}

template< class R, class T, class A >
inline const_nv_mem_fun1_t<R, T, A> nv_mem_fun(R (T::*pmf)(A) const) {
        return const_nv_mem_fun1_t<R, T, A>(pmf);
}

#endif /* NVMEMFUN_H */
Revision:	1.5
Committed:	2005-12-11T17:12:59Z (18 years, 11 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.4:	+25 -8 lines
Log Message:	add "fast" pointers to non-virtual member functions for MIPSpro compilers
#	User	Rev	Content
1	gbeauche	1.1	/*
2			* nvmemfun.hpp - Non-virtual member function wrappers
3			*
4			* Kheperix (C) 2003 Gwenole Beauchesne
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifndef NVMEMFUN_H
22			#define NVMEMFUN_H
23
24			#include <functional>
25
26	gbeauche	1.5	#if defined __GNUC__
27			#define HAVE_FAST_NV_MEM_FUN 1
28			#define MEM_FUN_WORDS 2
29			#if defined __GXX_ABI_VERSION /* GCC >= 3.0 */
30			#define MEM_FUN_OFFSET 0
31			#else
32			#define MEM_FUN_OFFSET 1
33			#endif
34			#endif
35
36			#if defined __ICC
37			#define HAVE_FAST_NV_MEM_FUN 1
38			#define MEM_FUN_WORDS 2
39			#define MEM_FUN_OFFSET 0 /* GNU C++ ABI v3 */
40			#endif
41
42			#if defined __EDG__ && defined __sgi
43			#define HAVE_FAST_NV_MEM_FUN 1
44			#define MEM_FUN_WORDS 3
45			#define MEM_FUN_OFFSET 2
46			#endif
47
48			#if HAVE_FAST_NV_MEM_FUN
49	gbeauche	1.1
50			template< class PMF, class PF >
51			inline PF nv_mem_fun_of(PMF pmf) {
52	gbeauche	1.4	if (pmf == 0)
53			return 0;
54	gbeauche	1.5	union { PMF pmf; uintptr p[MEM_FUN_WORDS]; } x;
55	gbeauche	1.1	x.pmf = pmf;
56	gbeauche	1.5	return (PF)x.p[MEM_FUN_OFFSET];
57	gbeauche	1.1	}
58
59			template< class R, class T >
60			class nv_mem_fun_t : public std::unary_function<T, R> {
61			typedef R (T::*pmf_t)();
62			typedef R (pf_t)(T );
63			pf_t pf;
64			public:
65			nv_mem_fun_t(pmf_t pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
66			R operator()(T p) const { return (pf)(p); }
67	gbeauche	1.2	pf_t ptr() const { return pf; }
68	gbeauche	1.1	};
69
70			template< class R, class T >
71			class const_nv_mem_fun_t : public std::unary_function<T, R> {
72			typedef R (T::*pmf_t)();
73			typedef R (pf_t)(T );
74			pf_t const pf;
75			public:
76			const_nv_mem_fun_t(pmf_t const pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
77			R operator()(const T p) const { return (pf)(p); }
78	gbeauche	1.2	pf_t ptr() const { return pf; }
79	gbeauche	1.1	};
80
81			template< class R, class T, class A >
82			class nv_mem_fun1_t : public std::binary_function<T, A, R> {
83			typedef R (T::*pmf_t)(A);
84			typedef R (pf_t)(T , A x);
85			pf_t pf;
86			public:
87			nv_mem_fun1_t(pmf_t pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
88			R operator()(T p, A x) const { return (pf)(p, x); }
89	gbeauche	1.2	pf_t ptr() const { return pf; }
90	gbeauche	1.1	};
91
92			template< class R, class T, class A >
93			class const_nv_mem_fun1_t : public std::binary_function<T, A, R> {
94			typedef R (T::*pmf_t)(A);
95			typedef R (pf_t)(T , A x);
96			pf_t const pf;
97			public:
98			const_nv_mem_fun1_t(pmf_t const pmf) : pf(nv_mem_fun_of<pmf_t, pf_t>(pmf)) {}
99			R operator()(const T p, A x) const { return (pf)(p, x); }
100	gbeauche	1.2	pf_t ptr() const { return pf; }
101	gbeauche	1.1	};
102
103			#else
104
105			template< class R, class T >
106			class nv_mem_fun_t : public std::unary_function<T, R> {
107	gbeauche	1.2	typedef R (T::*pmf_t)();
108			pmf_t pf;
109	gbeauche	1.1	public:
110			nv_mem_fun_t(R (T::*pmf)()) : pf(pmf) {}
111			R operator()(T p) const { return (p->pf)(); }
112	gbeauche	1.2	pmf_t ptr() const { return pf; }
113	gbeauche	1.1	};
114
115			template< class R, class T >
116			class const_nv_mem_fun_t : public std::unary_function<T, R> {
117	gbeauche	1.2	typedef R (T::*pmf_t)() const;
118			pmf_t pf;
119	gbeauche	1.1	public:
120			const_nv_mem_fun_t(R (T::*pmf)() const) : pf(pmf) {}
121			R operator()(const T p) const { return (p->pf)(); }
122	gbeauche	1.2	pmf_t ptr() const { return pf; }
123	gbeauche	1.1	};
124
125			template< class R, class T, class A >
126			class nv_mem_fun1_t : public std::binary_function<T, A, R> {
127	gbeauche	1.2	typedef R (T::*pmf_t)(A);
128			pmf_t pf;
129	gbeauche	1.1	public:
130			nv_mem_fun1_t(R (T::*pmf)(A)) : pf(pmf) {}
131			R operator()(T p, A x) const { return (p->pf)(x); }
132	gbeauche	1.2	pmf_t ptr() const { return pf; }
133	gbeauche	1.1	};
134
135			template< class R, class T, class A >
136			class const_nv_mem_fun1_t : public std::binary_function<T, A, R> {
137	gbeauche	1.2	typedef R (T::*pmf_t)(A) const;
138			pmf_t pf;
139	gbeauche	1.1	public:
140			const_nv_mem_fun1_t(R (T::*pmf)(A) const) : pf(pmf) {}
141			R operator()(const T p, A x) const { return (p->pf)(x); }
142	gbeauche	1.2	pmf_t ptr() const { return pf; }
143	gbeauche	1.1	};
144
145			#endif
146
147			template< class R, class T >
148			inline nv_mem_fun_t<R, T> nv_mem_fun(R (T::*pmf)()) {
149			return nv_mem_fun_t<R, T>(pmf);
150			}
151
152			template< class R, class T >
153			inline const_nv_mem_fun_t<R, T> nv_mem_fun(R (T::*pmf)() const) {
154			return const_nv_mem_fun_t<R, T>(pmf);
155			}
156
157			template< class R, class T, class A >
158			inline nv_mem_fun1_t<R, T, A> nv_mem_fun(R (T::*pmf)(A)) {
159			return nv_mem_fun1_t<R, T, A>(pmf);
160			}
161
162			template< class R, class T, class A >
163			inline const_nv_mem_fun1_t<R, T, A> nv_mem_fun(R (T::*pmf)(A) const) {
164			return const_nv_mem_fun1_t<R, T, A>(pmf);
165			}
166
167			#endif /* NVMEMFUN_H */