home *** CD-ROM | disk | FTP | other *** search
/ Beginning C++ Through Gam…rogramming (2nd Edition) / BCGP2E.ISO / bloodshed / devcpp-4.9.9.2_setup.exe / indirect_array.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  8KB  |  213 lines
  1. // The template and inlines for the -*- C++ -*- indirect_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 indirect_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 _INDIRECT_ARRAY_H
  39. #define _INDIRECT_ARRAY_H 1
  40.  
  41. #pragma GCC system_header
  42.  
  43. namespace std
  44. {
  45.   /**
  46.    *  @brief  Reference to arbitrary subset of an array.
  47.    *
  48.    *  An indirect_array is a reference to the actual elements of an array
  49.    *  specified by an ordered array of indices.  The way to get an indirect_array is to
  50.    *  call operator[](valarray<size_t>) on a valarray.  The returned
  51.    *  indirect_array then permits carrying operations out on the referenced
  52.    *  subset of elements in the original valarray.
  53.    *
  54.    *  For example, if an indirect_array is obtained using the array (4,2,0) as
  55.    *  an argument, and then assigned to an array containing (1,2,3), then the
  56.    *  underlying array will have array[0]==3, array[2]==2, and array[4]==1.
  57.    *
  58.    *  @param  Tp  Element type.
  59.    */
  60.   template <class _Tp>
  61.     class indirect_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.       indirect_array(const indirect_array&);
  71.  
  72.       ///  Assignment operator.  Assigns elements to corresponding elements
  73.       ///  of @a a.
  74.       indirect_array& operator=(const indirect_array&);
  75.  
  76.       ///  Assign slice elements to corresponding elements of @a v.
  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.       //    ~indirect_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.       ///  Copy constructor.  Both slices refer to the same underlying array.
  127.       indirect_array(_Array<_Tp>, size_t, _Array<size_t>);
  128.  
  129.       friend class valarray<_Tp>;
  130.       friend class gslice_array<_Tp>;
  131.  
  132.       const size_t     _M_sz;
  133.       const _Array<size_t> _M_index;
  134.       const _Array<_Tp>     _M_array;
  135.  
  136.       // not implemented
  137.       indirect_array();
  138.     };
  139.  
  140.   template<typename _Tp>
  141.     inline
  142.     indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
  143.     : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
  144.  
  145.   template<typename _Tp>
  146.      inline
  147.      indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
  148.                      _Array<size_t> __i)
  149.      : _M_sz(__s), _M_index(__i), _M_array(__a) {}
  150.  
  151.   template<typename _Tp>
  152.      inline indirect_array<_Tp>&
  153.      indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
  154.      {
  155.        std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
  156.        return *this;
  157.      }
  158.  
  159.  
  160.   template<typename _Tp>
  161.      inline void
  162.      indirect_array<_Tp>::operator=(const _Tp& __t) const
  163.      { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
  164.  
  165.   template<typename _Tp>
  166.      inline void
  167.      indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
  168.      { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
  169.  
  170.   template<typename _Tp>
  171.      template<class _Dom>
  172.        inline void
  173.        indirect_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
  174.        { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }
  175.  
  176. #undef _DEFINE_VALARRAY_OPERATOR
  177. #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)                \
  178.   template<typename _Tp>                        \
  179.     inline void                                \
  180.     indirect_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const\
  181.     {                                    \
  182.       _Array_augmented_##_Name(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); \
  183.     }                                    \
  184.                                     \
  185.   template<typename _Tp>                                                \
  186.     template<class _Dom>                                \
  187.       inline void                            \
  188.       indirect_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\
  189.       {                                    \
  190.     _Array_augmented_##_Name(_M_array, _M_index, __e, _M_sz);    \
  191.       }
  192.  
  193. _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
  194. _DEFINE_VALARRAY_OPERATOR(/, __divides)
  195. _DEFINE_VALARRAY_OPERATOR(%, __modulus)
  196. _DEFINE_VALARRAY_OPERATOR(+, __plus)
  197. _DEFINE_VALARRAY_OPERATOR(-, __minus)
  198. _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
  199. _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
  200. _DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
  201. _DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
  202. _DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
  203.  
  204. #undef _DEFINE_VALARRAY_OPERATOR
  205.  
  206. } // std::
  207.  
  208. #endif /* _INDIRECT_ARRAY_H */
  209.  
  210. // Local Variables:
  211. // mode:c++
  212. // End:
  213.