# gslice.h

Go to the documentation of this file.

    00001 // The template and inlines for the -*- C++ -*- gslice class.
    00002
    00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2004, 2005, 2006
    00004 // Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 2, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // You should have received a copy of the GNU General Public License along
    00018 // with this library; see the file COPYING.  If not, write to the Free
    00019 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    00020 // USA.
    00021
    00022 // As a special exception, you may use this file as part of a free software
    00023 // library without restriction.  Specifically, if other files instantiate
    00024 // templates or use macros or inline functions from this file, or you compile
    00025 // this file and link it with other files to produce an executable, this
    00026 // file does not by itself cause the resulting executable to be covered by
    00027 // the GNU General Public License.  This exception does not however
    00028 // invalidate any other reasons why the executable file might be covered by
    00029 // the GNU General Public License.
    00030
    00031 /** @file gslice.h
    00032  *  This is an internal header file, included by other library headers.
    00033  *  You should not attempt to use it directly.
    00034  */
    00035
    00036 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
    00037
    00038 #ifndef _GSLICE_H
    00039 #define _GSLICE_H 1
    00040
    00041 #pragma GCC system_header
    00042
    00043 _GLIBCXX_BEGIN_NAMESPACE(std)
    00044
    00045   /**
    00046    *  @brief  Class defining multi-dimensional subset of an array.
    00047    *
    00048    *  The slice class represents a multi-dimensional subset of an array,
    00049    *  specified by three parameter sets: start offset, size array, and stride
    00050    *  array.  The start offset is the index of the first element of the array
    00051    *  that is part of the subset.  The size and stride array describe each
    00052    *  dimension of the slice.  Size is the number of elements in that
    00053    *  dimension, and stride is the distance in the array between successive
    00054    *  elements in that dimension.  Each dimension's size and stride is taken
    00055    *  to begin at an array element described by the previous dimension.  The
    00056    *  size array and stride array must be the same size.
    00057    *
    00058    *  For example, if you have offset==3, stride[0]==11, size[1]==3,
    00059    *  stride[1]==3, then slice[0,0]==array[3], slice[0,1]==array[6],
    00060    *  slice[0,2]==array[9], slice[1,0]==array[14], slice[1,1]==array[17],
    00061    *  slice[1,2]==array[20].
    00062    */
    00063   class gslice
    00064   {
    00065   public:
    00066     ///  Construct an empty slice.
    00067     gslice();
    00068
    00069     /**
    00070      *  @brief  Construct a slice.
    00071      *
    00072      *  Constructs a slice with as many dimensions as the length of the @a l
    00073      *  and @a s arrays.
    00074      *
    00075      *  @param  o  Offset in array of first element.
    00076      *  @param  l  Array of dimension lengths.
    00077      *  @param  s  Array of dimension strides between array elements.
    00078      */
    00079     gslice(size_t, const valarray<size_t>&, const valarray<size_t>&);
    00080
    00081     // XXX: the IS says the copy-ctor and copy-assignment operators are
    00082     //      synthesized by the compiler but they are just unsuitable
    00083     //      for a ref-counted semantic
    00084     ///  Copy constructor.
    00085     gslice(const gslice&);
    00086
    00087     ///  Destructor.
    00088     ~gslice();
    00089
    00090     // XXX: See the note above.
    00091     ///  Assignment operator.
    00092     gslice& operator=(const gslice&);
    00093
    00094     ///  Return array offset of first slice element.
    00095     size_t           start() const;
    00096
    00097     ///  Return array of sizes of slice dimensions.
    00098     valarray<size_t> size() const;
    00099
    00100     ///  Return array of array strides for each dimension.
    00101     valarray<size_t> stride() const;
    00102
    00103   private:
    00104     struct _Indexer
    00105     {
    00106       size_t _M_count;
    00107       size_t _M_start;
    00108       valarray<size_t> _M_size;
    00109       valarray<size_t> _M_stride;
    00110       valarray<size_t> _M_index; // Linear array of referenced indices
    00111
    00112       _Indexer()
    00113       : _M_count(1), _M_start(0), _M_size(), _M_stride(), _M_index() {}
    00114
    00115       _Indexer(size_t, const valarray<size_t>&,
    00116            const valarray<size_t>&);
    00117
    00118       void
    00119       _M_increment_use()
    00120       { ++_M_count; }
    00121
    00122       size_t
    00123       _M_decrement_use()
    00124       { return --_M_count; }
    00125     };
    00126
    00127     _Indexer* _M_index;
    00128
    00129     template<typename _Tp> friend class valarray;
    00130   };
    00131
    00132   inline size_t
    00133   gslice::start() const
    00134   { return _M_index ? _M_index->_M_start : 0; }
    00135
    00136   inline valarray<size_t>
    00137   gslice::size() const
    00138   { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
    00139
    00140   inline valarray<size_t>
    00141   gslice::stride() const
    00142   { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
    00143
    00144   // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00145   // 543. valarray slice default constructor
    00146   inline
    00147   gslice::gslice()
    00148   : _M_index(new gslice::_Indexer()) {}
    00149
    00150   inline
    00151   gslice::gslice(size_t __o, const valarray<size_t>& __l,
    00152          const valarray<size_t>& __s)
    00153   : _M_index(new gslice::_Indexer(__o, __l, __s)) {}
    00154
    00155   inline
    00156   gslice::gslice(const gslice& __g)
    00157   : _M_index(__g._M_index)
    00158   { if (_M_index) _M_index->_M_increment_use(); }
    00159
    00160   inline
    00161   gslice::~gslice()
    00162   {
    00163     if (_M_index && _M_index->_M_decrement_use() == 0)
    00164       delete _M_index;
    00165   }
    00166
    00167   inline gslice&
    00168   gslice::operator=(const gslice& __g)
    00169   {
    00170     if (__g._M_index)
    00171       __g._M_index->_M_increment_use();
    00172     if (_M_index && _M_index->_M_decrement_use() == 0)
    00173       delete _M_index;
    00174     _M_index = __g._M_index;
    00175     return *this;
    00176   }
    00177
    00178 _GLIBCXX_END_NAMESPACE
    00179
    00180 #endif /* _GSLICE_H */