diff options
Diffstat (limited to 'external/boost/boost.multi_array.Wshadow.warnings.patch')
| -rw-r--r-- | external/boost/boost.multi_array.Wshadow.warnings.patch | 494 |
1 files changed, 494 insertions, 0 deletions
diff --git a/external/boost/boost.multi_array.Wshadow.warnings.patch b/external/boost/boost.multi_array.Wshadow.warnings.patch new file mode 100644 index 000000000000..661778674f78 --- /dev/null +++ b/external/boost/boost.multi_array.Wshadow.warnings.patch @@ -0,0 +1,494 @@ +--- misc/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/concept_checks.hpp 2012-01-12 20:29:56.482879277 +0000 +@@ -39,8 +39,8 @@ + + template <typename Array, typename IdxGen, typename Call_Type> + static void call(Array& a, const IdxGen& idgen, Call_Type c) { +- typedef typename Array::index_range index_range; +- typedef typename Array::index index; ++ typedef typename Array::index_range index_range_; ++ typedef typename Array::index index_; + idgen_helper<N-1>::call(a,idgen[c],c); + } + }; +@@ -50,8 +50,8 @@ + + template <typename Array, typename IdxGen, typename Call_Type> + static void call(Array& a, const IdxGen& idgen, Call_Type) { +- typedef typename Array::index_range index_range; +- typedef typename Array::index index; ++ typedef typename Array::index_range index_range_; ++ typedef typename Array::index index_; + a[ idgen ]; + } + }; +@@ -153,27 +153,27 @@ + const_constraints(a); + } + +- void const_constraints(const Array& a) { ++ void const_constraints(const Array& a_) { + + // value_type vt = a[ id ]; + + // Test slicing, keeping only the first dimension, losing the rest +- detail::idgen_helper<NumDims-1>::call(a,idgen[range],id); ++ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],id); + + // Test slicing, keeping all dimensions. +- detail::idgen_helper<NumDims-1>::call(a,idgen[range],range); ++ detail::idgen_helper<NumDims-1>::call(a_,idgen[range],range); + +- st = a.size(); +- st = a.num_dimensions(); +- st = a.num_elements(); +- stp = a.shape(); +- idp = a.strides(); +- idp = a.index_bases(); +- cit = a.begin(); +- cit = a.end(); +- crit = a.rbegin(); +- crit = a.rend(); +- eltp = a.origin(); ++ st = a_.size(); ++ st = a_.num_dimensions(); ++ st = a_.num_elements(); ++ stp = a_.shape(); ++ idp = a_.strides(); ++ idp = a_.index_bases(); ++ cit = a_.begin(); ++ cit = a_.end(); ++ crit = a_.rbegin(); ++ crit = a_.rend(); ++ eltp = a_.origin(); + } + + typedef typename Array::value_type value_type; +--- misc/boost_1_44_0/boost/multi_array/extent_range.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/extent_range.hpp 2012-01-12 20:32:16.696241748 +0000 +@@ -26,11 +26,11 @@ + typedef Extent index; + typedef SizeType size_type; + +- extent_range(index start, index finish) : +- super_type(start,finish) { } ++ extent_range(index start_, index finish_) : ++ super_type(start_,finish_) { } + +- extent_range(index finish) : +- super_type(0,finish) { } ++ extent_range(index finish_) : ++ super_type(0,finish_) { } + + extent_range() : super_type(0,0) { } + +--- misc/boost_1_44_0/boost/multi_array/index_range.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/index_range.hpp 2012-01-12 20:31:29.405781105 +0000 +@@ -60,8 +60,8 @@ + degenerate_ = true; + } + +- explicit index_range(index start, index finish, index stride=1) +- : start_(start), finish_(finish), stride_(stride), ++ explicit index_range(index i_start, index i_finish, index i_stride=1) ++ : start_(i_start), finish_(i_finish), stride_(i_stride), + degenerate_(false) + { } + +@@ -107,11 +107,11 @@ + + index stride() const { return stride_; } + +- void set_index_range(index start, index finish, index stride=1) ++ void set_index_range(index i_start, index i_finish, index i_stride=1) + { +- start_ = start; +- finish_ = finish; +- stride_ = stride; ++ start_ = i_start; ++ finish_ = i_finish; ++ stride_ = i_stride; + } + + static index_range all() +--- misc/boost_1_44_0/boost/multi_array/multi_array_ref.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/multi_array_ref.hpp 2012-01-12 20:25:49.280492556 +0000 +@@ -86,24 +86,24 @@ + num_elements_(other.num_elements_) { } + + template <typename ExtentList> +- explicit const_multi_array_ref(TPtr base, const ExtentList& extents) : ++ explicit const_multi_array_ref(TPtr base, const ExtentList& extents_) : + base_(base), storage_(c_storage_order()) { + boost::function_requires< + CollectionConcept<ExtentList> >(); + + index_base_list_.assign(0); +- init_multi_array_ref(extents.begin()); ++ init_multi_array_ref(extents_.begin()); + } + + template <typename ExtentList> +- explicit const_multi_array_ref(TPtr base, const ExtentList& extents, ++ explicit const_multi_array_ref(TPtr base, const ExtentList& extents_, + const general_storage_order<NumDims>& so) : + base_(base), storage_(so) { + boost::function_requires< + CollectionConcept<ExtentList> >(); + + index_base_list_.assign(0); +- init_multi_array_ref(extents.begin()); ++ init_multi_array_ref(extents_.begin()); + } + + explicit const_multi_array_ref(TPtr base, +@@ -124,13 +124,13 @@ + } + + template <class InputIterator> +- void assign(InputIterator begin, InputIterator end) { ++ void assign(InputIterator begin_, InputIterator end_) { + boost::function_requires<InputIteratorConcept<InputIterator> >(); + +- InputIterator in_iter = begin; ++ InputIterator in_iter = begin_; + T* out_iter = base_; + std::size_t copy_count=0; +- while (in_iter != end && copy_count < num_elements_) { ++ while (in_iter != end_ && copy_count < num_elements_) { + *out_iter++ = *in_iter++; + copy_count++; + } +@@ -161,14 +161,14 @@ + } + + template <typename SizeList> +- void reshape(const SizeList& extents) { ++ void reshape(const SizeList& extents_) { + boost::function_requires< + CollectionConcept<SizeList> >(); + BOOST_ASSERT(num_elements_ == +- std::accumulate(extents.begin(),extents.end(), ++ std::accumulate(extents_.begin(),extents_.end(), + size_type(1),std::multiplies<size_type>())); + +- std::copy(extents.begin(),extents.end(),extent_list_.begin()); ++ std::copy(extents_.begin(),extents_.end(),extent_list_.begin()); + this->compute_strides(stride_list_,extent_list_,storage_); + + origin_offset_ = +@@ -208,11 +208,11 @@ + } + + template <typename IndexList> +- const element& operator()(IndexList indices) const { ++ const element& operator()(IndexList indices_) const { + boost::function_requires< + CollectionConcept<IndexList> >(); + return super_type::access_element(boost::type<const element&>(), +- indices,origin(), ++ indices_,origin(), + shape(),strides(),index_bases()); + } + +@@ -231,12 +231,12 @@ + #endif // BOOST_MSVC + typename const_array_view<NDims>::type + operator[](const detail::multi_array:: +- index_gen<NumDims,NDims>& indices) ++ index_gen<NumDims,NDims>& indices_) + const { + typedef typename const_array_view<NDims>::type return_type; + return + super_type::generate_array_view(boost::type<return_type>(), +- indices, ++ indices_, + shape(), + strides(), + index_bases(), +@@ -327,20 +327,20 @@ + explicit + const_multi_array_ref(TPtr base, + const storage_order_type& so, +- const index * index_bases, ++ const index * index_bases_, +- const size_type* extents) : ++ const size_type* extents_) : + base_(base), storage_(so), origin_offset_(0), directional_offset_(0) + { +- // If index_bases or extents is null, then initialize the corresponding ++ // If index_bases_ or extents_ is null, then initialize the corresponding + // private data to zeroed lists. +- if(index_bases) { ++ if(index_bases_) { + boost::detail::multi_array:: +- copy_n(index_bases,NumDims,index_base_list_.begin()); ++ copy_n(index_bases_,NumDims,index_base_list_.begin()); + } else { + std::fill_n(index_base_list_.begin(),NumDims,0); + } +- if(extents) { +- init_multi_array_ref(extents); ++ if(extents_) { ++ init_multi_array_ref(extents_); + } else { + boost::array<index,NumDims> extent_list; + extent_list.assign(0); +@@ -374,12 +374,12 @@ + boost::mem_fun_ref(&extent_range::start)); + + // calculate the extents +- extent_list extents; ++ extent_list extents_; + std::transform(ranges.ranges_.begin(),ranges.ranges_.end(), +- extents.begin(), ++ extents_.begin(), + boost::mem_fun_ref(&extent_range::size)); + +- init_multi_array_ref(extents.begin()); ++ init_multi_array_ref(extents_.begin()); + } + + +@@ -445,16 +445,16 @@ + }; + + template <class ExtentList> +- explicit multi_array_ref(T* base, const ExtentList& extents) : +- super_type(base,extents) { ++ explicit multi_array_ref(T* base, const ExtentList& extents_) : ++ super_type(base,extents_) { + boost::function_requires< + CollectionConcept<ExtentList> >(); + } + + template <class ExtentList> +- explicit multi_array_ref(T* base, const ExtentList& extents, ++ explicit multi_array_ref(T* base, const ExtentList& extents_, + const general_storage_order<NumDims>& so) : +- super_type(base,extents,so) { ++ super_type(base,extents_,so) { + boost::function_requires< + CollectionConcept<ExtentList> >(); + } +@@ -509,11 +509,11 @@ + element* data() { return super_type::base_; } + + template <class IndexList> +- element& operator()(const IndexList& indices) { ++ element& operator()(const IndexList& indices_) { + boost::function_requires< + CollectionConcept<IndexList> >(); + return super_type::access_element(boost::type<element&>(), +- indices,origin(), ++ indices_,origin(), + this->shape(),this->strides(), + this->index_bases()); + } +@@ -535,11 +535,11 @@ + #endif // BOOST_MSVC + typename array_view<NDims>::type + operator[](const detail::multi_array:: +- index_gen<NumDims,NDims>& indices) { ++ index_gen<NumDims,NDims>& indices_) { + typedef typename array_view<NDims>::type return_type; + return + super_type::generate_array_view(boost::type<return_type>(), +- indices, ++ indices_, + this->shape(), + this->strides(), + this->index_bases(), +@@ -576,10 +576,10 @@ + const element* data() const { return super_type::data(); } + + template <class IndexList> +- const element& operator()(const IndexList& indices) const { ++ const element& operator()(const IndexList& indices_) const { + boost::function_requires< + CollectionConcept<IndexList> >(); +- return super_type::operator()(indices); ++ return super_type::operator()(indices_); + } + + const_reference operator[](index idx) const { +@@ -597,9 +597,9 @@ + #endif // BOOST_MSVC + typename const_array_view<NDims>::type + operator[](const detail::multi_array:: +- index_gen<NumDims,NDims>& indices) ++ index_gen<NumDims,NDims>& indices_) + const { +- return super_type::operator[](indices); ++ return super_type::operator[](indices_); + } + + const_iterator begin() const { +@@ -622,9 +622,9 @@ + // This is only supplied to support multi_array's default constructor + explicit multi_array_ref(T* base, + const storage_order_type& so, +- const index* index_bases, +- const size_type* extents) : +- super_type(base,so,index_bases,extents) { } ++ const index* index_bases_, ++ const size_type* extents_) : ++ super_type(base,so,index_bases_,extents_) { } + + }; + +--- misc/boost_1_44_0/boost/multi_array/storage_order.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/storage_order.hpp 2012-01-12 20:30:57.667472937 +0000 +@@ -34,10 +34,10 @@ + public: + typedef detail::multi_array::size_type size_type; + template <typename OrderingIter, typename AscendingIter> +- general_storage_order(OrderingIter ordering, +- AscendingIter ascending) { +- boost::detail::multi_array::copy_n(ordering,NumDims,ordering_.begin()); +- boost::detail::multi_array::copy_n(ascending,NumDims,ascending_.begin()); ++ general_storage_order(OrderingIter i_ordering, ++ AscendingIter i_ascending) { ++ boost::detail::multi_array::copy_n(i_ordering,NumDims,ordering_.begin()); ++ boost::detail::multi_array::copy_n(i_ascending,NumDims,ascending_.begin()); + } + + // RG - ideally these would not be necessary, but some compilers +--- misc/boost_1_44_0/boost/multi_array/subarray.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/subarray.hpp 2012-01-12 20:27:12.346292228 +0000 +@@ -181,9 +181,9 @@ + + const_sub_array (TPtr base, + const size_type* extents, +- const index* strides, ++ const index* i_strides, + const index* index_base) : +- base_(base), extents_(extents), strides_(strides), ++ base_(base), extents_(extents), strides_(i_strides), + index_base_(index_base) { + } + +@@ -369,9 +369,9 @@ + + sub_array (T* base, + const size_type* extents, +- const index* strides, ++ const index* _strides, + const index* index_base) : +- super_type(base,extents,strides,index_base) { ++ super_type(base,extents,_strides,index_base) { + } + + }; +--- misc/boost_1_44_0/boost/multi_array/view.hpp 2012-01-12 20:21:29.790009198 +0000 ++++ misc/build/boost_1_44_0/boost/multi_array/view.hpp 2012-01-12 20:26:36.350945110 +0000 +@@ -231,7 +231,7 @@ + template <typename ExtentList, typename Index> + explicit const_multi_array_view(TPtr base, + const ExtentList& extents, +- const boost::array<Index,NumDims>& strides): ++ const boost::array<Index,NumDims>& strides_): + base_(base), origin_offset_(0) { + + index_base_list_.assign(0); +@@ -240,7 +240,7 @@ + boost::detail::multi_array:: + copy_n(extents.begin(),NumDims,extent_list_.begin()); + boost::detail::multi_array:: +- copy_n(strides.begin(),NumDims,stride_list_.begin()); ++ copy_n(strides_.begin(),NumDims,stride_list_.begin()); + + // Calculate the array size + num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(), +@@ -441,8 +441,8 @@ + template <typename ExtentList, typename Index> + explicit multi_array_view(T* base, + const ExtentList& extents, +- const boost::array<Index,NumDims>& strides) : +- super_type(base,extents,strides) { } ++ const boost::array<Index,NumDims>& _strides) : ++ super_type(base,extents,_strides) { } + + }; + +--- misc/boost_1_44_0/boost/multi_array.hpp 2012-09-28 13:06:44.796521371 +0100 ++++ misc/build/boost_1_44_0/boost/multi_array.hpp 2012-09-28 13:07:25.119002500 +0100 +@@ -139,20 +139,20 @@ + + explicit multi_array() : + super_type((T*)initial_base_,c_storage_order(), +- /*index_bases=*/0, /*extents=*/0) { ++ /*index_bases=*/0, /*extents_=*/0) { + allocate_space(); + } + + template <class ExtentList> + explicit multi_array( +- ExtentList const& extents ++ ExtentList const& extents_ + #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + , typename mpl::if_< + detail::multi_array::is_multi_array_impl<ExtentList>, + int&,int>::type* = 0 + #endif + ) : +- super_type((T*)initial_base_,extents) { ++ super_type((T*)initial_base_,extents_) { + boost::function_requires< + detail::multi_array::CollectionConcept<ExtentList> >(); + allocate_space(); +@@ -160,19 +160,19 @@ + + + template <class ExtentList> +- explicit multi_array(ExtentList const& extents, ++ explicit multi_array(ExtentList const& extents_, + const general_storage_order<NumDims>& so) : +- super_type((T*)initial_base_,extents,so) { ++ super_type((T*)initial_base_,extents_,so) { + boost::function_requires< + detail::multi_array::CollectionConcept<ExtentList> >(); + allocate_space(); + } + + template <class ExtentList> +- explicit multi_array(ExtentList const& extents, ++ explicit multi_array(ExtentList const& extents_, + const general_storage_order<NumDims>& so, + Allocator const& alloc) : +- super_type((T*)initial_base_,extents,so), allocator_(alloc) { ++ super_type((T*)initial_base_,extents_,so), allocator_(alloc) { + boost::function_requires< + detail::multi_array::CollectionConcept<ExtentList> >(); + allocate_space(); +@@ -381,7 +381,7 @@ + + + template <typename ExtentList> +- multi_array& resize(const ExtentList& extents) { ++ multi_array& resize(const ExtentList& extents_) { + boost::function_requires< + detail::multi_array::CollectionConcept<ExtentList> >(); + +@@ -390,7 +390,7 @@ + + for (int i=0; i != NumDims; ++i) { + typedef typename gen_type::range range_type; +- ranges.ranges_[i] = range_type(0,extents[i]); ++ ranges.ranges_[i] = range_type(0,extents_[i]); + } + + return this->resize(ranges); +@@ -423,9 +423,9 @@ + // Build index_gen objects to create views with the same shape + + // these need to be separate to handle non-zero index bases +- typedef detail::multi_array::index_gen<NumDims,NumDims> index_gen; +- index_gen old_idxes; +- index_gen new_idxes; ++ typedef detail::multi_array::index_gen<NumDims,NumDims> lcl_index_gen; ++ lcl_index_gen old_idxes; ++ lcl_index_gen new_idxes; + + std::transform(new_array.index_base_list_.begin(), + new_array.index_base_list_.end(), |