headers/cpp/std/slice_array.h

   1 // The template and inlines for the -*- C++ -*- slice_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 __SLICE_ARRAY__
  33 #define __SLICE_ARRAY__
  34
  35 extern "C++" {
  36
  37 template<typename _T>
  38 class slice_array
  39 {
  40 public:
  41     typedef _T value_type;
  42
  43     void operator=   (const valarray<_T>&) const;
  44     void operator*=  (const valarray<_T>&) const;
  45     void operator/=  (const valarray<_T>&) const;
  46     void operator%=  (const valarray<_T>&) const;
  47     void operator+=  (const valarray<_T>&) const;
  48     void operator-=  (const valarray<_T>&) const;
  49     void operator^=  (const valarray<_T>&) const;
  50     void operator&=  (const valarray<_T>&) const;
  51     void operator|=  (const valarray<_T>&) const;
  52     void operator<<= (const valarray<_T>&) const;
  53     void operator>>= (const valarray<_T>&) const;
  54     void operator= (const _T &);
  55
  56     template<class _Dom>
  57     void operator=   (const _Expr<_Dom,_T>&) const;
  58     template<class _Dom>
  59     void operator*=  (const _Expr<_Dom,_T>&) const;
  60     template<class _Dom>
  61     void operator/=  (const _Expr<_Dom,_T>&) const;
  62     template<class _Dom>
  63     void operator%=  (const _Expr<_Dom,_T>&) const;
  64     template<class _Dom>
  65     void operator+=  (const _Expr<_Dom,_T>&) const;
  66     template<class _Dom>
  67     void operator-=  (const _Expr<_Dom,_T>&) const;
  68     template<class _Dom>
  69     void operator^=  (const _Expr<_Dom,_T>&) const;
  70     template<class _Dom>
  71     void operator&=  (const _Expr<_Dom,_T>&) const;
  72     template<class _Dom>
  73     void operator|=  (const _Expr<_Dom,_T>&) const;
  74     template<class _Dom>
  75     void operator<<= (const _Expr<_Dom,_T>&) const;
  76     template<class _Dom>
  77     void operator>>= (const _Expr<_Dom,_T>&) const;
  78
  79 private:
  80     friend class valarray<_T>;
  81     slice_array(_Array<_T>, const slice&);
  82
  83     const size_t     _M_sz;
  84     const size_t     _M_stride;
  85     const _Array<_T> _M_array;
  86
  87     // this constructor is implemented since we need to return a value.
  88     slice_array (const slice_array&);
  89
  90     // not implemented
  91     slice_array ();
  92     slice_array& operator= (const slice_array&);
  93 };
  94
  95 template<typename _T>
  96 inline slice_array<_T>::slice_array (_Array<_T> __a, const slice& __s)
  97         : _M_sz (__s.size ()), _M_stride (__s.stride ()),
  98           _M_array (__a.begin () + __s.start ()) {}
  99
 100 template<typename _Tp>
 101 inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
 102         : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
 103
 104 template<typename _T>
 105 inline void
 106 slice_array<_T>::operator= (const _T& __t)
 107 { __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
 108
 109 template<typename _T>
 110 inline void
 111 slice_array<_T>::operator= (const valarray<_T>& __v) const
 112 { __valarray_copy (_Array<_T> (__v), _M_array, _M_sz, _M_stride); }
 113
 114 template<typename _T>
 115 template<class _Dom>
 116 inline void
 117 slice_array<_T>::operator= (const _Expr<_Dom,_T>& __e) const
 118 { __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
 119
 120 #undef _DEFINE_VALARRAY_OPERATOR
 121 #define _DEFINE_VALARRAY_OPERATOR(op, name)                             \
 122 template<typename _T>                                                   \
 123 inline void                                                             \
 124 slice_array<_T>::operator##op##= (const valarray<_T>& __v) const        \
 125 {                                                                       \
 126   _Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_T> (__v));\
 127 }                                                                       \
 128                                                                         \
 129 template<typename _T> template<class _Dom>                              \
 130 inline void                                                             \
 131 slice_array<_T>::operator##op##= (const _Expr<_Dom,_T>& __e) const      \
 132 {                                                                       \
 133     _Array_augmented_##name (_M_array, _M_stride, __e, _M_sz);          \
 134 }
 135
 136
 137 _DEFINE_VALARRAY_OPERATOR(*, multiplies)
 138 _DEFINE_VALARRAY_OPERATOR(/, divides)
 139 _DEFINE_VALARRAY_OPERATOR(%, modulus)
 140 _DEFINE_VALARRAY_OPERATOR(+, plus)
 141 _DEFINE_VALARRAY_OPERATOR(-, minus)
 142 _DEFINE_VALARRAY_OPERATOR(^, xor)
 143 _DEFINE_VALARRAY_OPERATOR(&, and)
 144 _DEFINE_VALARRAY_OPERATOR(|, or)
 145 _DEFINE_VALARRAY_OPERATOR(<<, shift_left)
 146 _DEFINE_VALARRAY_OPERATOR(>>, shift_right)
 147
 148 #undef _DEFINE_VALARRAY_OPERATOR
 149
 150 } // extern "C++"
 151
 152 #endif // __SLICE_ARRAY__
 153
 154 // Local Variables:
 155 // mode:c++
 156 // End: