home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 April / PCWorld_2008-04_cd.bin / temacd / devc++ / devcpp-4.9.9.2_setup.exe / mask_array.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  8KB  |  210 lines
  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:
  210.