source: svn/trunk/newcon3bcm2_21bu/toolchain/include/c++/3.4.2/bits/gslice_array.h

Last change on this file was 2, checked in by jglee, 11 years ago

first commit
  • Property svn:executable set to *
File size: 7.8 KB
Line 
1// The template and inlines for the -*- C++ -*- gslice_array class.
2
3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2004
4// Free Software Foundation, Inc.
5//
6// This file is part of the GNU ISO C++ Library.  This library is free
7// software; you can redistribute it and/or modify it under the
8// terms of the GNU General Public License as published by the
9// Free Software Foundation; either version 2, or (at your option)
10// any later version.
11
12// This library is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15// GNU General Public License for more details.
16
17// You should have received a copy of the GNU General Public License along
18// with this library; see the file COPYING.  If not, write to the Free
19// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20// USA.
21
22// As a special exception, you may use this file as part of a free software
23// library without restriction.  Specifically, if other files instantiate
24// templates or use macros or inline functions from this file, or you compile
25// this file and link it with other files to produce an executable, this
26// file does not by itself cause the resulting executable to be covered by
27// the GNU General Public License.  This exception does not however
28// invalidate any other reasons why the executable file might be covered by
29// the GNU General Public License.
30
31// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
32
33/** @file gslice_array.h
34 *  This is an internal header file, included by other library headers.
35 *  You should not attempt to use it directly.
36 */
37
38#ifndef _GSLICE_ARRAY_H
39#define _GSLICE_ARRAY_H 1
40
41#pragma GCC system_header
42
43namespace std {
44
45  /**
46   *  @brief  Reference to multi-dimensional subset of an array.
47   *
48   *  A gslice_array is a reference to the actual elements of an array
49   *  specified by a gslice.  The way to get a gslice_array is to call
50   *  operator[](gslice) on a valarray.  The returned gslice_array then
51   *  permits carrying operations out on the referenced subset of elements in
52   *  the original valarray.  For example, operator+=(valarray) will add
53   *  values to the subset of elements in the underlying valarray this
54   *  gslice_array refers to.
55   *
56   *  @param  Tp  Element type.
57   */
58  template<typename _Tp>
59    class gslice_array
60    {
61    public:
62      typedef _Tp value_type;
63
64      // _GLIBCXX_RESOLVE_LIB_DEFECTS
65      // 253. valarray helper functions are almost entirely useless
66
67      ///  Copy constructor.  Both slices refer to the same underlying array.
68      gslice_array(const gslice_array&);
69
70      ///  Assignment operator.  Assigns slice elements to corresponding
71      ///  elements of @a a.
72      gslice_array& operator=(const gslice_array&);
73
74      ///  Assign slice elements to corresponding elements of @a v.
75      void operator=(const valarray<_Tp>&) const;
76      ///  Multiply slice elements by corresponding elements of @a v.
77      void operator*=(const valarray<_Tp>&) const;
78      ///  Divide slice elements by corresponding elements of @a v.
79      void operator/=(const valarray<_Tp>&) const;
80      ///  Modulo slice elements by corresponding elements of @a v.
81      void operator%=(const valarray<_Tp>&) const;
82      ///  Add corresponding elements of @a v to slice elements.
83      void operator+=(const valarray<_Tp>&) const;
84      ///  Subtract corresponding elements of @a v from slice elements.
85      void operator-=(const valarray<_Tp>&) const;
86      ///  Logical xor slice elements with corresponding elements of @a v.
87      void operator^=(const valarray<_Tp>&) const;
88      ///  Logical and slice elements with corresponding elements of @a v.
89      void operator&=(const valarray<_Tp>&) const;
90      ///  Logical or slice elements with corresponding elements of @a v.
91      void operator|=(const valarray<_Tp>&) const;
92      ///  Left shift slice elements by corresponding elements of @a v.
93      void operator<<=(const valarray<_Tp>&) const;
94      ///  Right shift slice elements by corresponding elements of @a v.
95      void operator>>=(const valarray<_Tp>&) const;
96      ///  Assign all slice elements to @a t.
97      void operator=(const _Tp&) const;
98
99      template<class _Dom>
100        void operator=(const _Expr<_Dom,_Tp>&) const;
101      template<class _Dom>
102        void operator*=(const _Expr<_Dom,_Tp>&) const;
103      template<class _Dom>
104        void operator/=(const _Expr<_Dom,_Tp>&) const;
105      template<class _Dom>
106        void operator%=(const _Expr<_Dom,_Tp>&) const;
107      template<class _Dom>
108        void operator+=(const _Expr<_Dom,_Tp>&) const;
109      template<class _Dom>
110        void operator-=(const _Expr<_Dom,_Tp>&) const;
111      template<class _Dom>
112        void operator^=(const _Expr<_Dom,_Tp>&) const;
113      template<class _Dom>
114        void operator&=(const _Expr<_Dom,_Tp>&) const;
115      template<class _Dom>
116        void operator|=(const _Expr<_Dom,_Tp>&) const;
117      template<class _Dom>
118        void operator<<=(const _Expr<_Dom,_Tp>&) const;
119      template<class _Dom>
120        void operator>>=(const _Expr<_Dom,_Tp>&) const;
121
122    private:
123      _Array<_Tp>    _M_array;
124      const valarray<size_t>& _M_index;
125
126      friend class valarray<_Tp>;
127
128      gslice_array(_Array<_Tp>, const valarray<size_t>&);
129
130      // not implemented
131      gslice_array();
132    };
133
134  template<typename _Tp>
135    inline
136    gslice_array<_Tp>::gslice_array(_Array<_Tp> __a,
137                                    const valarray<size_t>& __i)
138    : _M_array(__a), _M_index(__i) {}
139
140
141  template<typename _Tp>
142    inline
143    gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
144    : _M_array(__a._M_array), _M_index(__a._M_index) {}
145
146
147  template<typename _Tp>
148    inline gslice_array<_Tp>&
149    gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a)
150    {
151      std::__valarray_copy(_Array<_Tp>(__a._M_array),
152                           _Array<size_t>(__a._M_index), _M_index.size(),
153                           _M_array, _Array<size_t>(_M_index));
154      return *this;
155    }
156
157  template<typename _Tp>
158    inline void
159    gslice_array<_Tp>::operator=(const _Tp& __t) const
160    {
161      std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
162                           _M_index.size(), __t);
163    }
164
165  template<typename _Tp>
166    inline void
167    gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
168    {
169      std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
170                           _M_array, _Array<size_t>(_M_index));
171    }
172
173  template<typename _Tp>
174    template<class _Dom>
175      inline void
176      gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
177      {
178        std::__valarray_copy (__e, _M_index.size(), _M_array,
179                              _Array<size_t>(_M_index));
180      }
181
182#undef _DEFINE_VALARRAY_OPERATOR
183#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)                           \
184  template<typename _Tp>                                                \
185    inline void                                                         \
186    gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const  \
187    {                                                                   \
188      _Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index),      \
189                              _Array<_Tp>(__v), __v.size());            \
190    }                                                                   \
191                                                                        \
192  template<typename _Tp>                                                \
193    template<class _Dom>                                                \
194      inline void                                                       \
195      gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _Tp>& __e) const\
196      {                                                                 \
197        _Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index), __e,\
198                                 _M_index.size());                      \
199      }
200
201_DEFINE_VALARRAY_OPERATOR(*, __multiplies)
202_DEFINE_VALARRAY_OPERATOR(/, __divides)
203_DEFINE_VALARRAY_OPERATOR(%, __modulus)
204_DEFINE_VALARRAY_OPERATOR(+, __plus)
205_DEFINE_VALARRAY_OPERATOR(-, __minus)
206_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
207_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
208_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
209_DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
210_DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
211
212#undef _DEFINE_VALARRAY_OPERATOR
213
214} // std::
215
216#endif /* _GSLICE_ARRAY_H */
217
218// Local Variables:
219// mode:c++
220// End:
Note: See TracBrowser for help on using the repository browser.