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

   1 // The template and inlines for the -*- C++ -*- indirect_array class.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
   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 _CPP_BITS_INDIRECT_ARRAY_H
  39 #define _CPP_BITS_INDIRECT_ARRAY_H 1
  40
  41 #pragma GCC system_header
  42
  43 namespace std
  44 {
  45   template <class _Tp>
  46      class indirect_array
  47      {
  48      public:
  49        typedef _Tp value_type;
  50
  51        // XXX: This is a proposed resolution for DR-253.
  52        indirect_array& operator=(const indirect_array&);
  53
  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 valarray<_Tp>&) const;
  65        void operator= (const _Tp&) const;
  66        //    ~indirect_array();
  67
  68        template<class _Dom>
  69          void operator=(const _Expr<_Dom, _Tp>&) const;
  70        template<class _Dom>
  71          void operator*=(const _Expr<_Dom, _Tp>&) const;
  72        template<class _Dom>
  73          void operator/=(const _Expr<_Dom, _Tp>&) const;
  74        template<class _Dom>
  75          void operator%=(const _Expr<_Dom, _Tp>&) const;
  76        template<class _Dom>
  77          void operator+=(const _Expr<_Dom, _Tp>&) const;
  78        template<class _Dom>
  79          void operator-=(const _Expr<_Dom, _Tp>&) const;
  80        template<class _Dom>
  81          void operator^=(const _Expr<_Dom, _Tp>&) const;
  82        template<class _Dom>
  83          void operator&=(const _Expr<_Dom, _Tp>&) const;
  84        template<class _Dom>
  85          void operator|=(const _Expr<_Dom, _Tp>&) const;
  86        template<class _Dom>
  87          void operator<<=(const _Expr<_Dom, _Tp>&) const;
  88        template<class _Dom>
  89          void operator>>=(const _Expr<_Dom, _Tp>&) const;
  90
  91      private:
  92        indirect_array(const indirect_array&);
  93        indirect_array(_Array<_Tp>, size_t, _Array<size_t>);
  94
  95        friend class valarray<_Tp>;
  96        friend class gslice_array<_Tp>;
  97
  98        const size_t      _M_sz;
  99        const _Array<size_t> _M_index;
 100        const _Array<_Tp>         _M_array;
 101
 102        // not implemented
 103        indirect_array();
 104      };
 105
 106   template<typename _Tp>
 107     inline
 108     indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
 109       : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
 110
 111   template<typename _Tp>
 112      inline
 113      indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
 114                                          _Array<size_t> __i)
 115        : _M_sz(__s), _M_index(__i), _M_array(__a) {}
 116
 117   template<typename _Tp>
 118      inline indirect_array<_Tp>&
 119      indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
 120      {
 121        __valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
 122        return *this;
 123      }
 124
 125
 126   template<typename _Tp>
 127      inline void
 128      indirect_array<_Tp>::operator=(const _Tp& __t) const
 129      { __valarray_fill(_M_array, _M_index, _M_sz, __t); }
 130
 131   template<typename _Tp>
 132      inline void
 133      indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
 134      { __valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
 135
 136   template<typename _Tp>
 137      template<class _Dom>
 138        inline void
 139        indirect_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
 140        { __valarray_copy(__e, _M_sz, _M_array, _M_index); }
 141
 142 #undef _DEFINE_VALARRAY_OPERATOR
 143 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)                           \
 144   template<typename _Tp>                                                \
 145     inline void                                                         \
 146     indirect_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const\
 147     {                                                                   \
 148       _Array_augmented_##_Name(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); \
 149     }                                                                   \
 150                                                                         \
 151   template<typename _Tp>                                                \
 152     template<class _Dom>                                                \
 153       inline void                                                       \
 154       indirect_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\
 155       {                                                                 \
 156         _Array_augmented_##_Name(_M_array, _M_index, __e, _M_sz);       \
 157       }
 158
 159 _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
 160 _DEFINE_VALARRAY_OPERATOR(/, __divides)
 161 _DEFINE_VALARRAY_OPERATOR(%, __modulus)
 162 _DEFINE_VALARRAY_OPERATOR(+, __plus)
 163 _DEFINE_VALARRAY_OPERATOR(-, __minus)
 164 _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
 165 _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
 166 _DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
 167 _DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
 168 _DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
 169
 170 #undef _DEFINE_VALARRAY_OPERATOR
 171
 172 } // std::
 173
 174 #endif /* _CPP_BITS_INDIRECT_ARRAY_H */
 175
 176 // Local Variables:
 177 // mode:c++
 178 // End: