contrib/gcc-4.0/libstdc++-v3/include/bits/gslice.h

   1 // The template and inlines for the -*- C++ -*- gslice class.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 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 gslice.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 _GSLICE_H
  39 #define _GSLICE_H 1
  40
  41 #pragma GCC system_header
  42
  43 namespace std
  44 {
  45   /**
  46    *  @brief  Class defining multi-dimensional subset of an array.
  47    *
  48    *  The slice class represents a multi-dimensional subset of an array,
  49    *  specified by three parameter sets: start offset, size array, and stride
  50    *  array.  The start offset is the index of the first element of the array
  51    *  that is part of the subset.  The size and stride array describe each
  52    *  dimension of the slice.  Size is the number of elements in that
  53    *  dimension, and stride is the distance in the array between successive
  54    *  elements in that dimension.  Each dimension's size and stride is taken
  55    *  to begin at an array element described by the previous dimension.  The
  56    *  size array and stride array must be the same size.
  57    *
  58    *  For example, if you have offset==3, stride[0]==11, size[1]==3,
  59    *  stride[1]==3, then slice[0,0]==array[3], slice[0,1]==array[6],
  60    *  slice[0,2]==array[9], slice[1,0]==array[14], slice[1,1]==array[17],
  61    *  slice[1,2]==array[20].
  62    */
  63   class gslice
  64   {
  65   public:
  66     ///  Construct an empty slice.
  67     gslice ();
  68
  69     /**
  70      *  @brief  Construct a slice.
  71      *
  72      *  Constructs a slice with as many dimensions as the length of the @a l
  73      *  and @a s arrays.
  74      *
  75      *  @param  o  Offset in array of first element.
  76      *  @param  l  Array of dimension lengths.
  77      *  @param  s  Array of dimension strides between array elements.
  78      */
  79     gslice(size_t, const valarray<size_t>&, const valarray<size_t>&);
  80
  81     // XXX: the IS says the copy-ctor and copy-assignment operators are
  82     //      synthetized by the compiler but they are just unsuitable
  83     //      for a ref-counted semantic
  84     ///  Copy constructor.
  85     gslice(const gslice&);
  86
  87     ///  Destructor.
  88     ~gslice();
  89
  90     // XXX: See the note above.
  91     ///  Assignment operator.
  92     gslice& operator=(const gslice&);
  93
  94     ///  Return array offset of first slice element.
  95     size_t           start() const;
  96
  97     ///  Return array of sizes of slice dimensions.
  98     valarray<size_t> size() const;
  99
 100     ///  Return array of array strides for each dimension.
 101     valarray<size_t> stride() const;
 102
 103   private:
 104     struct _Indexer
 105     {
 106       size_t _M_count;
 107       size_t _M_start;
 108       valarray<size_t> _M_size;
 109       valarray<size_t> _M_stride;
 110       valarray<size_t> _M_index; // Linear array of referenced indices
 111       _Indexer(size_t, const valarray<size_t>&,
 112                const valarray<size_t>&);
 113       void
 114       _M_increment_use()
 115       { ++_M_count; }
 116
 117       size_t
 118       _M_decrement_use()
 119       { return --_M_count; }
 120     };
 121
 122     _Indexer* _M_index;
 123
 124     template<typename _Tp> friend class valarray;
 125   };
 126
 127   inline size_t
 128   gslice::start () const
 129   { return _M_index ? _M_index->_M_start : 0; }
 130
 131   inline valarray<size_t>
 132   gslice::size () const
 133   { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
 134
 135   inline valarray<size_t>
 136   gslice::stride () const
 137   { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
 138
 139   inline gslice::gslice () : _M_index(0) {}
 140
 141   inline
 142   gslice::gslice(size_t __o, const valarray<size_t>& __l,
 143                  const valarray<size_t>& __s)
 144   : _M_index(new gslice::_Indexer(__o, __l, __s)) {}
 145
 146   inline
 147   gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
 148   { if (_M_index) _M_index->_M_increment_use(); }
 149
 150   inline
 151   gslice::~gslice()
 152   {
 153     if (_M_index && _M_index->_M_decrement_use() == 0)
 154       delete _M_index;
 155   }
 156
 157   inline gslice&
 158   gslice::operator= (const gslice& __g)
 159   {
 160     if (__g._M_index)
 161       __g._M_index->_M_increment_use();
 162     if (_M_index && _M_index->_M_decrement_use() == 0)
 163       delete _M_index;
 164     _M_index = __g._M_index;
 165     return *this;
 166   }
 167
 168 } // std::
 169
 170 #endif /* _GSLICE_H */
 171
 172 // Local Variables:
 173 // mode:c++
 174 // End: