Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // The template and inlines for the -*- C++ -*- mask_array class.
  2.  
  3. // Copyright (C) 1997-2015 Free Software Foundation, Inc.
  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 3, 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. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /** @file bits/mask_array.h
  26.  *  This is an internal header file, included by other library headers.
  27.  *  Do not attempt to use it directly. @headername{valarray}
  28.  */
  29.  
  30. // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
  31.  
  32. #ifndef _MASK_ARRAY_H
  33. #define _MASK_ARRAY_H 1
  34.  
  35. #pragma GCC system_header
  36.  
  37. namespace std _GLIBCXX_VISIBILITY(default)
  38. {
  39. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  40.  
  41.   /**
  42.    * @addtogroup numeric_arrays
  43.    * @{
  44.    */
  45.  
  46.   /**
  47.    *  @brief  Reference to selected subset of an array.
  48.    *
  49.    *  A mask_array is a reference to the actual elements of an array specified
  50.    *  by a bitmask in the form of an array of bool.  The way to get a
  51.    *  mask_array is to call operator[](valarray<bool>) on a valarray.  The
  52.    *  returned mask_array then permits carrying operations out on the
  53.    *  referenced subset of elements in the original valarray.
  54.    *
  55.    *  For example, if a mask_array is obtained using the array (false, true,
  56.    *  false, true) as an argument, the mask array has two elements referring
  57.    *  to array[1] and array[3] in the underlying array.
  58.    *
  59.    *  @param  Tp  Element type.
  60.    */
  61.   template <class _Tp>
  62.     class mask_array
  63.     {
  64.     public:
  65.       typedef _Tp value_type;
  66.  
  67.       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  68.       // 253. valarray helper functions are almost entirely useless
  69.  
  70.       ///  Copy constructor.  Both slices refer to the same underlying array.
  71.       mask_array (const mask_array&);
  72.      
  73.       ///  Assignment operator.  Assigns elements to corresponding elements
  74.       ///  of @a a.
  75.       mask_array& operator=(const mask_array&);
  76.  
  77.       void operator=(const valarray<_Tp>&) const;
  78.       ///  Multiply slice elements by corresponding elements of @a v.
  79.       void operator*=(const valarray<_Tp>&) const;
  80.       ///  Divide slice elements by corresponding elements of @a v.
  81.       void operator/=(const valarray<_Tp>&) const;
  82.       ///  Modulo slice elements by corresponding elements of @a v.
  83.       void operator%=(const valarray<_Tp>&) const;
  84.       ///  Add corresponding elements of @a v to slice elements.
  85.       void operator+=(const valarray<_Tp>&) const;
  86.       ///  Subtract corresponding elements of @a v from slice elements.
  87.       void operator-=(const valarray<_Tp>&) const;
  88.       ///  Logical xor slice elements with corresponding elements of @a v.
  89.       void operator^=(const valarray<_Tp>&) const;
  90.       ///  Logical and slice elements with corresponding elements of @a v.
  91.       void operator&=(const valarray<_Tp>&) const;
  92.       ///  Logical or slice elements with corresponding elements of @a v.
  93.       void operator|=(const valarray<_Tp>&) const;
  94.       ///  Left shift slice elements by corresponding elements of @a v.
  95.       void operator<<=(const valarray<_Tp>&) const;
  96.       ///  Right shift slice elements by corresponding elements of @a v.
  97.       void operator>>=(const valarray<_Tp>&) const;
  98.       ///  Assign all slice elements to @a t.
  99.       void operator=(const _Tp&) const;
  100.  
  101.         //        ~mask_array ();
  102.  
  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.       template<class _Dom>
  122.         void operator<<=(const _Expr<_Dom,_Tp>&) const;
  123.       template<class _Dom>
  124.         void operator>>=(const _Expr<_Dom,_Tp>&) const;
  125.  
  126.     private:
  127.       mask_array(_Array<_Tp>, size_t, _Array<bool>);
  128.       friend class valarray<_Tp>;
  129.  
  130.       const size_t       _M_sz;
  131.       const _Array<bool> _M_mask;
  132.       const _Array<_Tp>  _M_array;
  133.  
  134.       // not implemented
  135.       mask_array();
  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.   // @} group numeric_arrays
  204.  
  205. _GLIBCXX_END_NAMESPACE_VERSION
  206. } // namespace
  207.  
  208. #endif /* _MASK_ARRAY_H */
  209.