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

   1 // The template and inlines for the -*- C++ -*- indirect_array class.
   2
   3 // Copyright (C) 1997-2001 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
  31
  32 /** @file indirect_array.h
  33  *  This is an internal header file, included by other library headers.
  34  *  You should not attempt to use it directly.
  35  */
  36
  37 #ifndef _CPP_BITS_INDIRECT_ARRAY_H
  38 #define _CPP_BITS_INDIRECT_ARRAY_H 1
  39
  40 #pragma GCC system_header
  41
  42 namespace std
  43 {
  44   template <class _Tp>
  45      class indirect_array
  46      {
  47      public:
  48        typedef _Tp value_type;
  49
  50        // XXX: This is a proposed resolution for DR-253.
  51        indirect_array& operator= (const indirect_array&);
  52
  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 valarray<_Tp>&) const;
  63        void operator>>= (const valarray<_Tp>&) const;
  64        void operator= (const _Tp&);
  65        //    ~indirect_array();
  66
  67        template<class _Dom>
  68        void operator=  (const _Expr<_Dom, _Tp>&) const;
  69        template<class _Dom>
  70        void operator*= (const _Expr<_Dom, _Tp>&) const;
  71        template<class _Dom>
  72        void operator/= (const _Expr<_Dom, _Tp>&) const;
  73        template<class _Dom>
  74        void operator%= (const _Expr<_Dom, _Tp>&) const;
  75        template<class _Dom>
  76        void operator+= (const _Expr<_Dom, _Tp>&) const;
  77        template<class _Dom>
  78        void operator-= (const _Expr<_Dom, _Tp>&) const;
  79        template<class _Dom>
  80        void operator^= (const _Expr<_Dom, _Tp>&) const;
  81        template<class _Dom>
  82        void operator&= (const _Expr<_Dom, _Tp>&) const;
  83        template<class _Dom>
  84        void operator|= (const _Expr<_Dom, _Tp>&) const;
  85        template<class _Dom>
  86        void operator<<= (const _Expr<_Dom, _Tp>&) const;
  87        template<class _Dom>
  88        void operator>>= (const _Expr<_Dom, _Tp>&) const;
  89
  90      private:
  91        indirect_array (const indirect_array&);
  92        indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
  93
  94        friend class valarray<_Tp>;
  95        friend class gslice_array<_Tp>;
  96
  97        const size_t      _M_sz;
  98        const _Array<size_t> _M_index;
  99        const _Array<_Tp>         _M_array;
 100
 101        // not implemented
 102        indirect_array ();
 103      };
 104
 105   template<typename _Tp>
 106   inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
 107           : _M_sz (__a._M_sz), _M_index (__a._M_index),
 108             _M_array (__a._M_array) {}
 109
 110   template<typename _Tp>
 111      inline
 112      indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
 113                                           _Array<size_t> __i)
 114              : _M_sz (__s), _M_index (__i), _M_array (__a) {}
 115
 116   template<typename _Tp>
 117      inline indirect_array<_Tp>&
 118      indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
 119      {
 120        __valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
 121        return *this;
 122      }
 123
 124
 125   template<typename _Tp>
 126      inline void
 127      indirect_array<_Tp>::operator= (const _Tp& __t)
 128      { __valarray_fill(_M_array, _M_index, _M_sz, __t); }
 129
 130   template<typename _Tp>
 131      inline void
 132      indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
 133      { __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
 134
 135   template<typename _Tp>
 136      template<class _Dom>
 137      inline void
 138      indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
 139      { __valarray_copy (__e, _M_sz, _M_array, _M_index); }
 140
 141 #undef _DEFINE_VALARRAY_OPERATOR
 142 #define _DEFINE_VALARRAY_OPERATOR(op, name)                             \
 143 template<typename _Tp>                                                  \
 144 inline void                                                             \
 145 indirect_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const    \
 146 {                                                                       \
 147   _Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
 148 }                                                                       \
 149                                                                         \
 150 template<typename _Tp> template<class _Dom>                             \
 151 inline void                                                             \
 152 indirect_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \
 153 {                                                                       \
 154   _Array_augmented_##name (_M_array, _M_index, __e, _M_sz);             \
 155 }
 156
 157 _DEFINE_VALARRAY_OPERATOR(*, multiplies)
 158 _DEFINE_VALARRAY_OPERATOR(/, divides)
 159 _DEFINE_VALARRAY_OPERATOR(%, modulus)
 160 _DEFINE_VALARRAY_OPERATOR(+, plus)
 161 _DEFINE_VALARRAY_OPERATOR(-, minus)
 162 _DEFINE_VALARRAY_OPERATOR(^, xor)
 163 _DEFINE_VALARRAY_OPERATOR(&, and)
 164 _DEFINE_VALARRAY_OPERATOR(|, or)
 165 _DEFINE_VALARRAY_OPERATOR(<<, shift_left)
 166 _DEFINE_VALARRAY_OPERATOR(>>, shift_right)
 167
 168 #undef _DEFINE_VALARRAY_OPERATOR
 169
 170 } // std::
 171
 172 #endif /* _CPP_BITS_INDIRECT_ARRAY_H */
 173
 174 // Local Variables:
 175 // mode:c++
 176 // End: