libstdc++-v3/include/bits/mask_array.h

   1 // The template and inlines for the -*- C++ -*- mask_array class.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
   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 mask_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 _MASK_ARRAY_H
  39 #define _MASK_ARRAY_H 1
  40
  41 #pragma GCC system_header
  42
  43 namespace std {
  44
  45   template <class _Tp>
  46     class mask_array
  47     {
  48     public:
  49       typedef _Tp value_type;
  50
  51       void operator=(const valarray<_Tp>&) const;
  52       void operator*=(const valarray<_Tp>&) const;
  53       void operator/=(const valarray<_Tp>&) const;
  54       void operator%=(const valarray<_Tp>&) const;
  55       void operator+=(const valarray<_Tp>&) const;
  56       void operator-=(const valarray<_Tp>&) const;
  57       void operator^=(const valarray<_Tp>&) const;
  58       void operator&=(const valarray<_Tp>&) const;
  59       void operator|=(const valarray<_Tp>&) const;
  60       void operator<<=(const valarray<_Tp>&) const;
  61       void operator>>=(const valarray<_Tp>&) const;
  62       void operator=(const _Tp&) const;
  63
  64         //        ~mask_array ();
  65
  66       template<class _Dom>
  67         void operator=(const _Expr<_Dom,_Tp>&) const;
  68       template<class _Dom>
  69         void operator*=(const _Expr<_Dom,_Tp>&) const;
  70       template<class _Dom>
  71         void operator/=(const _Expr<_Dom,_Tp>&) const;
  72       template<class _Dom>
  73         void operator%=(const _Expr<_Dom,_Tp>&) const;
  74       template<class _Dom>
  75         void operator+=(const _Expr<_Dom,_Tp>&) const;
  76       template<class _Dom>
  77         void operator-=(const _Expr<_Dom,_Tp>&) const;
  78       template<class _Dom>
  79         void operator^=(const _Expr<_Dom,_Tp>&) const;
  80       template<class _Dom>
  81         void operator&=(const _Expr<_Dom,_Tp>&) const;
  82       template<class _Dom>
  83         void operator|=(const _Expr<_Dom,_Tp>&) const;
  84       template<class _Dom>
  85         void operator<<=(const _Expr<_Dom,_Tp>&) const;
  86       template<class _Dom>
  87         void operator>>=(const _Expr<_Dom,_Tp>&) const;
  88
  89     private:
  90       mask_array(_Array<_Tp>, size_t, _Array<bool>);
  91       friend class valarray<_Tp>;
  92
  93       const size_t       _M_sz;
  94       const _Array<bool> _M_mask;
  95       const _Array<_Tp>   _M_array;
  96
  97       mask_array (const mask_array&);
  98
  99       // not implemented
 100       mask_array();
 101       mask_array& operator=(const mask_array&);
 102     };
 103
 104
 105   template<typename _Tp>
 106     inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a)
 107       : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {}
 108
 109   template<typename _Tp>
 110     inline
 111     mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array<bool> __m)
 112       : _M_sz(__s), _M_mask(__m), _M_array(__a) {}
 113
 114   template<typename _Tp>
 115     inline void
 116     mask_array<_Tp>::operator=(const _Tp& __t) const
 117     { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); }
 118
 119   template<typename _Tp>
 120     inline void
 121     mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
 122     { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }
 123
 124   template<typename _Tp>
 125     template<class _Ex>
 126       inline void
 127       mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const
 128       { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); }
 129
 130 #undef _DEFINE_VALARRAY_OPERATOR
 131 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)                           \
 132   template<typename _Tp>                                                \
 133     inline void                                                         \
 134     mask_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const    \
 135     {                                                                   \
 136       _Array_augmented_##_Name(_M_array, _M_mask,                       \
 137                                _Array<_Tp>(__v), __v.size());           \
 138     }                                                                   \
 139                                                                         \
 140   template<typename _Tp>                                                \
 141     template<class _Dom>                                                \
 142       inline void                                                       \
 143       mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) const\
 144       {                                                                 \
 145         _Array_augmented_##_Name(_M_array, _M_mask, __e, __e.size());   \
 146       }
 147
 148 _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
 149 _DEFINE_VALARRAY_OPERATOR(/, __divides)
 150 _DEFINE_VALARRAY_OPERATOR(%, __modulus)
 151 _DEFINE_VALARRAY_OPERATOR(+, __plus)
 152 _DEFINE_VALARRAY_OPERATOR(-, __minus)
 153 _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
 154 _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
 155 _DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
 156 _DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
 157 _DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
 158
 159 #undef _DEFINE_VALARRAY_OPERATOR
 160
 161 } // std::
 162
 163 #endif /* _MASK_ARRAY_H */
 164
 165 // Local Variables:
 166 // mode:c++
 167 // End: