Ticket #8038: smart_ptr.diff

File smart_ptr.diff, 4.3 KB (added by Franz Detro <franz.detro@…>, 10 years ago)

  • boost/smart_ptr/detail/allocate_array_helper.hpp 

    From 4476df2b764e3662326bdb2458d8928deca83456 Mon Sep 17 00:00:00 2001
From: Franz Detro <franz.detro@native-instruments.de>
Date: Mon, 11 Feb 2013 12:35:23 +0100
Subject: [PATCH] fix warnings in boost smart_ptr

---
 boost/smart_ptr/detail/allocate_array_helper.hpp | 14 +++++++-------
 boost/smart_ptr/detail/array_deleter.hpp         |  4 ++--
 boost/smart_ptr/detail/make_array_helper.hpp     | 14 +++++++-------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/boost/smart_ptr/detail/allocate_array_helper.hpp b/boost/smart_ptr/detail/allocate_array_helper.hpp
index f7c64fe..2eeea2d 100644
    a b namespace boost {  
    3333            struct rebind {
    3434                typedef allocate_array_helper<A, T[], U> other;
    3535            };
    36             allocate_array_helper(const A& allocator, std::size_t size, T** data)
    37                 : allocator(allocator),
    38                   size(sizeof(T) * size),
    39                   data(data) {
     36            allocate_array_helper(const A& allocator_, std::size_t size_, T** data_)
     37                : allocator(allocator_),
     38                  size(sizeof(T) * size_),
     39                  data(data_) {
    4040            }
    4141            template<class U>
    4242            allocate_array_helper(const allocate_array_helper<A, T[], U>& other)
    … … namespace boost {  
    107107            struct rebind {
    108108                typedef allocate_array_helper<A, T[N], U> other;
    109109            };
    110             allocate_array_helper(const A& allocator, T** data)
    111                 : allocator(allocator),
    112                   data(data) {
     110            allocate_array_helper(const A& allocator_, T** data_)
     111                : allocator(allocator_),
     112                  data(data_) {
    113113            }
    114114            template<class U>
    115115            allocate_array_helper(const allocate_array_helper<A, T[N], U>& other)

  • boost/smart_ptr/detail/array_deleter.hpp 

    diff --git a/boost/smart_ptr/detail/array_deleter.hpp b/boost/smart_ptr/detail/array_deleter.hpp
index 11f23fa..20f84d1 100644
    a b namespace boost {  
    1919        template<typename T>
    2020        class array_deleter<T[]> {
    2121        public:
    22             array_deleter(std::size_t size)
    23                 : size(size),
     22            array_deleter(std::size_t size_)
     23                : size(size_),
    2424                  object(0) {
    2525            }
    2626            ~array_deleter() {

  • boost/smart_ptr/detail/make_array_helper.hpp 

    diff --git a/boost/smart_ptr/detail/make_array_helper.hpp b/boost/smart_ptr/detail/make_array_helper.hpp
index 38c9dc9..cf6598a 100644
    a b namespace boost {  
    3131            struct rebind {
    3232                typedef make_array_helper<T[], U> other;
    3333            };
    34             make_array_helper(std::size_t size, T** data)
    35                 : size(sizeof(T) * size),
    36                   data(data) {
     34            make_array_helper(std::size_t size_, T** data_)
     35                : size(sizeof(T) * size_),
     36                  data(data_) {
    3737            }
    3838            template<class U>
    3939            make_array_helper(const make_array_helper<T[], U>& other)
    … … namespace boost {  
    7272                memory->~Y();
    7373            }
    7474            template<typename U>
    75             bool operator==(const make_array_helper<T[], U>& other) const {
     75            bool operator==(const make_array_helper<T[], U>& /*other*/) const {
    7676                return true;
    7777            }
    7878            template<typename U>
    … … namespace boost {  
    9999            struct rebind {
    100100                typedef make_array_helper<T[N], U> other;
    101101            };
    102             make_array_helper(T** data)
    103                 : data(data) {
     102            make_array_helper(T** data_)
     103                : data(data_) {
    104104            }
    105105            template<class U>
    106106            make_array_helper(const make_array_helper<T[N], U>& other)
    … … namespace boost {  
    138138                memory->~Y();
    139139            }
    140140            template<typename U>
    141             bool operator==(const make_array_helper<T[N], U>& other) const {
     141            bool operator==(const make_array_helper<T[N], U>& /*other*/) const {
    142142                return true;
    143143            }
    144144            template<typename U>