mingw/include/c++/3.4.2/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, 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 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   /**
  46    *  @brief  Reference to selected subset of an array.
  47    *
  48    *  A mask_array is a reference to the actual elements of an array specified
  49    *  by a bitmask in the form of an array of bool.  The way to get a
  50    *  mask_array is to call operator[](valarray<bool>) on a valarray.  The
  51    *  returned mask_array then permits carrying operations out on the
  52    *  referenced subset of elements in the original valarray.
  53    *
  54    *  For example, if a mask_array is obtained using the array (false, true,
  55    *  false, true) as an argument, the mask array has two elements referring
  56    *  to array[1] and array[3] in the underlying array.
  57    *
  58    *  @param  Tp  Element type.
  59    */
  60   template <class _Tp>
  61     class mask_array
  62     {
  63     public:
  64       typedef _Tp value_type;
  65
  66       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  67       // 253. valarray helper functions are almost entirely useless
  68
  69       ///  Copy constructor.  Both slices refer to the same underlying array.
  70       mask_array (const mask_array&);
  71
  72       ///  Assignment operator.  Assigns elements to corresponding elements
  73       ///  of @a a.
  74       mask_array& operator=(const mask_array&);
  75
  76       void operator=(const valarray<_Tp>&) const;
  77       ///  Multiply slice elements by corresponding elements of @a v.
  78       void operator*=(const valarray<_Tp>&) const;
  79       ///  Divide slice elements by corresponding elements of @a v.
  80       void operator/=(const valarray<_Tp>&) const;
  81       ///  Modulo slice elements by corresponding elements of @a v.
  82       void operator%=(const valarray<_Tp>&) const;
  83       ///  Add corresponding elements of @a v to slice elements.
  84       void operator+=(const valarray<_Tp>&) const;
  85       ///  Subtract corresponding elements of @a v from slice elements.
  86       void operator-=(const valarray<_Tp>&) const;
  87       ///  Logical xor slice elements with corresponding elements of @a v.
  88       void operator^=(const valarray<_Tp>&) const;
  89       ///  Logical and slice elements with corresponding elements of @a v.
  90       void operator&=(const valarray<_Tp>&) const;
  91       ///  Logical or slice elements with corresponding elements of @a v.
  92       void operator|=(const valarray<_Tp>&) const;
  93       ///  Left shift slice elements by corresponding elements of @a v.
  94       void operator<<=(const valarray<_Tp>&) const;
  95       ///  Right shift slice elements by corresponding elements of @a v.
  96       void operator>>=(const valarray<_Tp>&) const;
  97       ///  Assign all slice elements to @a t.
  98       void operator=(const _Tp&) const;
  99
 100         //        ~mask_array ();
 101
 102       template<class _Dom>
 103         void operator=(const _Expr<_Dom,_Tp>&) const;
 104       template<class _Dom>
 105         void operator*=(const _Expr<_Dom,_Tp>&) const;
 106       template<class _Dom>
 107         void operator/=(const _Expr<_Dom,_Tp>&) const;
 108       template<class _Dom>
 109         void operator%=(const _Expr<_Dom,_Tp>&) const;
 110       template<class _Dom>
 111         void operator+=(const _Expr<_Dom,_Tp>&) const;
 112       template<class _Dom>
 113         void operator-=(const _Expr<_Dom,_Tp>&) const;
 114       template<class _Dom>
 115         void operator^=(const _Expr<_Dom,_Tp>&) const;
 116       template<class _Dom>
 117         void operator&=(const _Expr<_Dom,_Tp>&) const;
 118       template<class _Dom>
 119         void operator|=(const _Expr<_Dom,_Tp>&) const;
 120       template<class _Dom>
 121         void operator<<=(const _Expr<_Dom,_Tp>&) const;
 122       template<class _Dom>
 123         void operator>>=(const _Expr<_Dom,_Tp>&) const;
 124
 125     private:
 126       mask_array(_Array<_Tp>, size_t, _Array<bool>);
 127       friend class valarray<_Tp>;
 128
 129       const size_t       _M_sz;
 130       const _Array<bool> _M_mask;
 131       const _Array<_Tp>   _M_array;
 132
 133       // not implemented
 134       mask_array();
 135     };
 136
 137
 138   template<typename _Tp>
 139     inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a)
 140     : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {}
 141
 142   template<typename _Tp>
 143     inline
 144     mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array<bool> __m)
 145     : _M_sz(__s), _M_mask(__m), _M_array(__a) {}
 146
 147   template<typename _Tp>
 148     inline mask_array<_Tp>&
 149     mask_array<_Tp>::operator=(const mask_array<_Tp>& __a)
 150     {
 151       std::__valarray_copy(__a._M_array, __a._M_mask,
 152                            _M_sz, _M_array, _M_mask);
 153       return *this;
 154     }
 155
 156   template<typename _Tp>
 157     inline void
 158     mask_array<_Tp>::operator=(const _Tp& __t) const
 159     { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); }
 160
 161   template<typename _Tp>
 162     inline void
 163     mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
 164     { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }
 165
 166   template<typename _Tp>
 167     template<class _Ex>
 168       inline void
 169       mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const
 170       { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); }
 171
 172 #undef _DEFINE_VALARRAY_OPERATOR
 173 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)                           \
 174   template<typename _Tp>                                                \
 175     inline void                                                         \
 176     mask_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const    \
 177     {                                                                   \
 178       _Array_augmented_##_Name(_M_array, _M_mask,                       \
 179                                _Array<_Tp>(__v), __v.size());           \
 180     }                                                                   \
 181                                                                         \
 182   template<typename _Tp>                                                \
 183     template<class _Dom>                                                \
 184       inline void                                                       \
 185       mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) const\
 186       {                                                                 \
 187         _Array_augmented_##_Name(_M_array, _M_mask, __e, __e.size());   \
 188       }
 189
 190 _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
 191 _DEFINE_VALARRAY_OPERATOR(/, __divides)
 192 _DEFINE_VALARRAY_OPERATOR(%, __modulus)
 193 _DEFINE_VALARRAY_OPERATOR(+, __plus)
 194 _DEFINE_VALARRAY_OPERATOR(-, __minus)
 195 _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
 196 _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
 197 _DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
 198 _DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
 199 _DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
 200
 201 #undef _DEFINE_VALARRAY_OPERATOR
 202
 203 } // std::
 204
 205 #endif /* _MASK_ARRAY_H */
 206
 207 // Local Variables:
 208 // mode:c++
 209 // End: