1// The template and inlines for the -*- C++ -*- indirect_array class.
2
3// Copyright (C) 1997-1999 Cygnus Solutions
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 2, or (at your option)
9// any later version.
10
11// This library 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 along
17// with this library; see the file COPYING.  If not, write to the Free
18// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19// USA.
20
21// As a special exception, you may use this file as part of a free software
22// library without restriction.  Specifically, if other files instantiate
23// templates or use macros or inline functions from this file, or you compile
24// this file and link it with other files to produce an executable, this
25// file does not by itself cause the resulting executable to be covered by
26// the GNU General Public License.  This exception does not however
27// invalidate any other reasons why the executable file might be covered by
28// the GNU General Public License.
29
30// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
31
32#ifndef __INDIRECT_ARRAY__
33#define __INDIRECT_ARRAY__
34
35extern "C++" {
36
37template <class _Tp> class indirect_array
38{
39public:
40    typedef _Tp value_type;
41
42    void operator=  (const valarray<_Tp>&) const;
43    void operator*= (const valarray<_Tp>&) const;
44    void operator/= (const valarray<_Tp>&) const;
45    void operator%= (const valarray<_Tp>&) const;
46    void operator+= (const valarray<_Tp>&) const;
47    void operator-= (const valarray<_Tp>&) const;
48    void operator^= (const valarray<_Tp>&) const;
49    void operator&= (const valarray<_Tp>&) const;
50    void operator|= (const valarray<_Tp>&) const;
51    void operator<<= (const valarray<_Tp>&) const;
52    void operator>>= (const valarray<_Tp>&) const;
53    void operator= (const _Tp&);
54
55    template<class _Dom>
56    void operator=  (const _Expr<_Dom, _Tp>&) const;
57    template<class _Dom>
58    void operator*= (const _Expr<_Dom, _Tp>&) const;
59    template<class _Dom>
60    void operator/= (const _Expr<_Dom, _Tp>&) const;
61    template<class _Dom>
62    void operator%= (const _Expr<_Dom, _Tp>&) const;
63    template<class _Dom>
64    void operator+= (const _Expr<_Dom, _Tp>&) const;
65    template<class _Dom>
66    void operator-= (const _Expr<_Dom, _Tp>&) const;
67    template<class _Dom>
68    void operator^= (const _Expr<_Dom, _Tp>&) const;
69    template<class _Dom>
70    void operator&= (const _Expr<_Dom, _Tp>&) const;
71    template<class _Dom>
72    void operator|= (const _Expr<_Dom, _Tp>&) const;
73    template<class _Dom>
74    void operator<<= (const _Expr<_Dom, _Tp>&) const;
75    template<class _Dom>
76    void operator>>= (const _Expr<_Dom, _Tp>&) const;
77
78private:
79    indirect_array (const indirect_array&);
80    indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
81
82    friend class valarray<_Tp>;
83    friend class gslice_array<_Tp>;
84
85    const size_t 	 _M_sz;
86    const _Array<size_t> _M_index;
87    const _Array<_Tp> 	 _M_array;
88
89    // not implemented
90    indirect_array ();
91    indirect_array& operator= (const indirect_array&);
92};
93
94template<typename _Tp>
95inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
96        : _M_sz (__a._M_sz), _M_index (__a._M_index),
97          _M_array (__a._M_array) {}
98
99template<typename _Tp>
100inline
101indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
102                                     _Array<size_t> __i)
103        : _M_sz (__s), _M_index (__i), _M_array (__a) {}
104
105
106template<typename _Tp>
107inline void
108indirect_array<_Tp>::operator= (const _Tp& __t)
109{ __valarray_fill(_M_array, _M_index, _M_sz, __t); }
110
111template<typename _Tp>
112inline void
113indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
114{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
115
116template<typename _Tp>
117template<class _Dom>
118inline void
119indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
120{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
121
122#undef _DEFINE_VALARRAY_OPERATOR
123#define _DEFINE_VALARRAY_OPERATOR(op, name)				\
124template<typename _Tp>							\
125inline void								\
126indirect_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const	\
127{									\
128  _Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
129}									\
130									\
131template<typename _Tp> template<class _Dom>				\
132inline void								\
133indirect_array<_Tp>::operator##op##= (const _Expr<_Dom,_Tp>& __e) const \
134{									\
135  _Array_augmented_##name (_M_array, _M_index, __e, _M_sz);		\
136}
137
138_DEFINE_VALARRAY_OPERATOR(*, multiplies)
139_DEFINE_VALARRAY_OPERATOR(/, divides)
140_DEFINE_VALARRAY_OPERATOR(%, modulus)
141_DEFINE_VALARRAY_OPERATOR(+, plus)
142_DEFINE_VALARRAY_OPERATOR(-, minus)
143_DEFINE_VALARRAY_OPERATOR(^, xor)
144_DEFINE_VALARRAY_OPERATOR(&, and)
145_DEFINE_VALARRAY_OPERATOR(|, or)
146_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
147_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
148
149#undef _DEFINE_VALARRAY_OPERATOR
150
151} // extern "C++"
152
153#endif // __INDIRECT_ARRAY__
154
155// Local Variables:
156// mode:c++
157// End:
158