X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=libstdc%2B%2B-v3%2Finclude%2Fbits%2Fslice_array.h;h=3afae22d6c4b7c1669e2f216df8ed4db7ae93d32;hp=2502ef4ebee925903da37b21fcf9f972da2f10d0;hb=18861b9e86e161d92c7570f9e2e7b1a5efcf6def;hpb=a4348cae815d970dc37e4e0e5a585d9572557eb3 diff --git a/libstdc++-v3/include/bits/slice_array.h b/libstdc++-v3/include/bits/slice_array.h index 2502ef4ebee..3afae22d6c4 100644 --- a/libstdc++-v3/include/bits/slice_array.h +++ b/libstdc++-v3/include/bits/slice_array.h @@ -1,11 +1,12 @@ // The template and inlines for the -*- C++ -*- slice_array class. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2009, +// 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) +// Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, @@ -13,126 +14,183 @@ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . -// Written by Gabriel Dos Reis - -/** @file slice_array.h +/** @file bits/slice_array.h * This is an internal header file, included by other library headers. - * You should not attempt to use it directly. + * Do not attempt to use it directly. @headername{valarray} */ -#ifndef _CPP_BITS_SLICE_ARRAY_H -#define _CPP_BITS_SLICE_ARRAY_H 1 +// Written by Gabriel Dos Reis + +#ifndef _SLICE_ARRAY_H +#define _SLICE_ARRAY_H 1 #pragma GCC system_header -namespace std +namespace std _GLIBCXX_VISIBILITY(default) { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Class defining one-dimensional subset of an array. + * + * The slice class represents a one-dimensional subset of an array, + * specified by three parameters: start offset, size, and stride. The + * start offset is the index of the first element of the array that is part + * of the subset. The size is the total number of elements in the subset. + * Stride is the distance between each successive array element to include + * in the subset. + * + * For example, with an array of size 10, and a slice with offset 1, size 3 + * and stride 2, the subset consists of array elements 1, 3, and 5. + */ class slice { public: + /// Construct an empty slice. slice(); + + /** + * @brief Construct a slice. + * + * @param o Offset in array of first element. + * @param d Number of elements in slice. + * @param s Stride between array elements. + */ slice(size_t, size_t, size_t); - + + /// Return array offset of first slice element. size_t start() const; + /// Return size of slice. size_t size() const; + /// Return array stride of slice. size_t stride() const; - + private: size_t _M_off; // offset size_t _M_sz; // size size_t _M_st; // stride unit }; - // The default constructor constructor is not required to initialize - // data members with any meaningful values, so we choose to do nothing. - inline - slice::slice() {} - - inline + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 543. valarray slice default constructor + inline + slice::slice() + : _M_off(0), _M_sz(0), _M_st(0) {} + + inline slice::slice(size_t __o, size_t __d, size_t __s) - : _M_off(__o), _M_sz(__d), _M_st(__s) {} - + : _M_off(__o), _M_sz(__d), _M_st(__s) {} + inline size_t slice::start() const { return _M_off; } - + inline size_t slice::size() const { return _M_sz; } - + inline size_t slice::stride() const { return _M_st; } + /** + * @brief Reference to one-dimensional subset of an array. + * + * A slice_array is a reference to the actual elements of an array + * specified by a slice. The way to get a slice_array is to call + * operator[](slice) on a valarray. The returned slice_array then permits + * carrying operations out on the referenced subset of elements in the + * original valarray. For example, operator+=(valarray) will add values + * to the subset of elements in the underlying valarray this slice_array + * refers to. + * + * @param Tp Element type. + */ template class slice_array { public: typedef _Tp value_type; - // This constructor is implemented since we need to return a value. + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 253. valarray helper functions are almost entirely useless + + /// Copy constructor. Both slices refer to the same underlying array. slice_array(const slice_array&); - // This operator must be public. See DR-253. + /// Assignment operator. Assigns slice elements to corresponding + /// elements of @a a. slice_array& operator=(const slice_array&); + /// Assign slice elements to corresponding elements of @a v. void operator=(const valarray<_Tp>&) const; + /// Multiply slice elements by corresponding elements of @a v. void operator*=(const valarray<_Tp>&) const; + /// Divide slice elements by corresponding elements of @a v. void operator/=(const valarray<_Tp>&) const; + /// Modulo slice elements by corresponding elements of @a v. void operator%=(const valarray<_Tp>&) const; + /// Add corresponding elements of @a v to slice elements. void operator+=(const valarray<_Tp>&) const; + /// Subtract corresponding elements of @a v from slice elements. void operator-=(const valarray<_Tp>&) const; + /// Logical xor slice elements with corresponding elements of @a v. void operator^=(const valarray<_Tp>&) const; + /// Logical and slice elements with corresponding elements of @a v. void operator&=(const valarray<_Tp>&) const; + /// Logical or slice elements with corresponding elements of @a v. void operator|=(const valarray<_Tp>&) const; + /// Left shift slice elements by corresponding elements of @a v. void operator<<=(const valarray<_Tp>&) const; + /// Right shift slice elements by corresponding elements of @a v. void operator>>=(const valarray<_Tp>&) const; + /// Assign all slice elements to @a t. void operator=(const _Tp &) const; // ~slice_array (); template - void operator=(const _Expr<_Dom,_Tp>&) const; + void operator=(const _Expr<_Dom, _Tp>&) const; template - void operator*=(const _Expr<_Dom,_Tp>&) const; + void operator*=(const _Expr<_Dom, _Tp>&) const; template - void operator/=(const _Expr<_Dom,_Tp>&) const; + void operator/=(const _Expr<_Dom, _Tp>&) const; template - void operator%=(const _Expr<_Dom,_Tp>&) const; + void operator%=(const _Expr<_Dom, _Tp>&) const; template - void operator+=(const _Expr<_Dom,_Tp>&) const; + void operator+=(const _Expr<_Dom, _Tp>&) const; template - void operator-=(const _Expr<_Dom,_Tp>&) const; + void operator-=(const _Expr<_Dom, _Tp>&) const; template - void operator^=(const _Expr<_Dom,_Tp>&) const; + void operator^=(const _Expr<_Dom, _Tp>&) const; template - void operator&=(const _Expr<_Dom,_Tp>&) const; + void operator&=(const _Expr<_Dom, _Tp>&) const; template - void operator|=(const _Expr<_Dom,_Tp>&) const; + void operator|=(const _Expr<_Dom, _Tp>&) const; template - void operator<<=(const _Expr<_Dom,_Tp>&) const; + void operator<<=(const _Expr<_Dom, _Tp>&) const; template - void operator>>=(const _Expr<_Dom,_Tp>&) const; + void operator>>=(const _Expr<_Dom, _Tp>&) const; private: friend class valarray<_Tp>; slice_array(_Array<_Tp>, const slice&); - const size_t _M_sz; - const size_t _M_stride; + const size_t _M_sz; + const size_t _M_stride; const _Array<_Tp> _M_array; // not implemented @@ -140,16 +198,16 @@ namespace std }; template - inline + inline slice_array<_Tp>::slice_array(_Array<_Tp> __a, const slice& __s) - : _M_sz(__s.size()), _M_stride(__s.stride()), - _M_array(__a.begin() + __s.start()) {} + : _M_sz(__s.size()), _M_stride(__s.stride()), + _M_array(__a.begin() + __s.start()) {} template - inline + inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a) - : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {} - + : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {} + // template // inline slice_array<_Tp>::~slice_array () {} @@ -157,26 +215,26 @@ namespace std inline slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array<_Tp>& __a) { - __valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, - _M_array, _M_stride); + std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, + _M_array, _M_stride); return *this; } template inline void slice_array<_Tp>::operator=(const _Tp& __t) const - { __valarray_fill(_M_array, _M_sz, _M_stride, __t); } - + { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); } + template inline void slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const - { __valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); } - + { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); } + template template inline void slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const - { __valarray_copy(__e, _M_sz, _M_array, _M_stride); } + { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); } #undef _DEFINE_VALARRAY_OPERATOR #define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) \ @@ -194,7 +252,7 @@ namespace std { \ _Array_augmented_##_Name(_M_array, _M_stride, __e, _M_sz); \ } - + _DEFINE_VALARRAY_OPERATOR(*, __multiplies) _DEFINE_VALARRAY_OPERATOR(/, __divides) @@ -209,10 +267,9 @@ _DEFINE_VALARRAY_OPERATOR(>>, __shift_right) #undef _DEFINE_VALARRAY_OPERATOR -} // std:: + // @} group numeric_arrays -#endif /* _CPP_BITS_SLICE_ARRAY_H */ +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace -// Local Variables: -// mode:c++ -// End: +#endif /* _SLICE_ARRAY_H */