Changeset 81748


Ignore:
Timestamp:
Dec 7, 2012, 1:53:35 AM (6 years ago)
Author:
Glen Fernandes
Message:

Refactoring in detail array_deleter before adding support for special-casing trivially default-constructible construction and trivially destroyable destruction.

Location:
trunk/boost/smart_ptr
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/boost/smart_ptr/allocate_shared_array.hpp

    r81700 r81748  
    1414#include <boost/smart_ptr/detail/array_deleter.hpp>
    1515#include <boost/smart_ptr/detail/array_traits.hpp>
    16 #include <boost/smart_ptr/detail/sp_forward.hpp>
    1716#include <boost/smart_ptr/detail/sp_if_array.hpp>
    1817#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
  • trunk/boost/smart_ptr/detail/array_deleter.hpp

    r81700 r81748  
    1010#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
    1111
    12 #include <boost/config.hpp>
    13 #include <cstddef>
     12#include <boost/smart_ptr/detail/array_utility.hpp>
     13#include <boost/smart_ptr/detail/sp_forward.hpp>
    1414
    1515namespace boost {
     
    2525            }
    2626            ~array_deleter() {
    27                 destroy(size);
     27                if (object) {
     28                    array_destroy(object, size);
     29                }
    2830            }
    2931            void construct(T* memory) {
    30                 std::size_t i = 0;
    31                 try {
    32                     for (object = memory; i < size; i++) {
    33                         void* p1 = memory + i;
    34                         ::new(p1) T();
    35                     }
    36                 } catch (...) {
    37                     destroy(i);
    38                     throw;
    39                 }
     32                array_construct(memory, size);
     33                object = memory;
    4034            }
    4135#if defined(BOOST_HAS_RVALUE_REFS)
    4236            void construct(T* memory, T&& value) {
    43                 std::size_t i = 0;
    44                 try {
    45                     for (object = memory; i < size; i++) {
    46                         void* p1 = memory + i;
    47                         ::new(p1) T(value);
    48                     }
    49                 } catch (...) {
    50                     destroy(i);
    51                     throw;
    52                 }
     37                array_construct(memory, size, value);
     38                object = memory;               
    5339            }
    5440#if defined(BOOST_HAS_VARIADIC_TMPL)
    5541            template<typename... Args>
    5642            void construct(T* memory, Args&&... args) {
    57                 std::size_t i = 0;
    58                 try {
    59                     for (object = memory; i < size; i++) {
    60                         void* p1 = memory + i;
    61                         ::new(p1) T(args...);
    62                     }
    63                 } catch (...) {
    64                     destroy(i);
    65                     throw;
    66                 }
     43                array_construct(memory, size, args...);
     44                object = memory;
    6745            }
    6846#endif
    6947#endif
    7048            void construct_list(T* memory, const T* list) {
    71                 std::size_t i = 0;
    72                 try {
    73                     for (object = memory; i < size; i++) {
    74                         void* p1 = memory + i;
    75                         ::new(p1) T(list[i]);
    76                     }
    77                 } catch (...) {
    78                     destroy(i);
    79                     throw;
    80                 }
     49                array_construct_list(memory, size, list);
     50                object = memory;
    8151            }
    8252            void construct_list(T* memory, const T* list, std::size_t n) {
    83                 std::size_t i = 0;
    84                 try {
    85                     for (object = memory; i < size; i++) {
    86                         void* p1 = memory + i;
    87                         ::new(p1) T(list[i % n]);
    88                     }
    89                 } catch (...) {
    90                     destroy(i);
    91                     throw;
    92                 }
     53                array_construct_list(memory, size, list, n);
     54                object = memory;
    9355            }
    9456            void construct_noinit(T* memory) {
    95                 std::size_t i = 0;
    96                 try {
    97                     for (object = memory; i < size; i++) {
    98                         void* p1 = memory + i;
    99                         ::new(p1) T;
    100                     }
    101                 } catch (...) {
    102                     destroy(i);
    103                     throw;
    104                 }
     57                array_construct_noinit(memory, size);
     58                object = memory;
    10559            }
    10660            void operator()(const void*) {
    107                 destroy(size);
    108             }
    109         private:
    110             void destroy(std::size_t n) {
    11161                if (object) {
    112                     for (std::size_t i = n; i > 0; ) {
    113                         object[--i].~T();
    114                     }
     62                    array_destroy(object, size);
    11563                    object = 0;
    11664                }
    11765            }
     66        private:
    11867            std::size_t size;
    11968            T* object;
     
    12675            }
    12776            ~array_deleter() {
    128                 destroy(N);
     77                if (object) {
     78                    array_destroy(object, N);
     79                }
    12980            }
    13081            void construct(T* memory) {
    131                 std::size_t i = 0;
    132                 try {
    133                     for (object = memory; i < N; i++) {
    134                         void* p1 = memory + i;
    135                         ::new(p1) T();
    136                     }
    137                 } catch (...) {
    138                     destroy(i);
    139                     throw;
    140                 }
     82                array_construct(memory, N);
     83                object = memory;
    14184            }
    14285#if defined(BOOST_HAS_RVALUE_REFS)
    14386            void construct(T* memory, T&& value) {
    144                 std::size_t i = 0;
    145                 try {
    146                     for (object = memory; i < N; i++) {
    147                         void* p1 = memory + i;
    148                         ::new(p1) T(value);
    149                     }
    150                 } catch (...) {
    151                     destroy(i);
    152                     throw;
    153                 }
     87                array_construct(memory, N, value);
     88                object = memory;               
    15489            }
    15590#if defined(BOOST_HAS_VARIADIC_TMPL)
    15691            template<typename... Args>
    15792            void construct(T* memory, Args&&... args) {
    158                 std::size_t i = 0;
    159                 try {
    160                     for (object = memory; i < N; i++) {
    161                         void* p1 = memory + i;
    162                         ::new(p1) T(args...);
    163                     }
    164                 } catch (...) {
    165                     destroy(i);
    166                     throw;
    167                 }
     93                array_construct(memory, N, args...);
     94                object = memory;
    16895            }
    16996#endif
    17097#endif
    17198            void construct_list(T* memory, const T* list) {
    172                 std::size_t i = 0;
    173                 try {
    174                     for (object = memory; i < N; i++) {
    175                         void* p1 = memory + i;
    176                         ::new(p1) T(list[i]);
    177                     }
    178                 } catch (...) {
    179                     destroy(i);
    180                     throw;
    181                 }
     99                array_construct_list(memory, N, list);
     100                object = memory;
    182101            }
    183102            void construct_list(T* memory, const T* list, std::size_t n) {
    184                 std::size_t i = 0;
    185                 try {
    186                     for (object = memory; i < N; i++) {
    187                         void* p1 = memory + i;
    188                         ::new(p1) T(list[i % n]);
    189                     }
    190                 } catch (...) {
    191                     destroy(i);
    192                     throw;
    193                 }
     103                array_construct_list(memory, N, list, n);
     104                object = memory;
    194105            }
    195106            void construct_noinit(T* memory) {
    196                 std::size_t i = 0;
    197                 try {
    198                     for (object = memory; i < N; i++) {
    199                         void* p1 = memory + i;
    200                         ::new(p1) T;
    201                     }
    202                 } catch (...) {
    203                     destroy(i);
    204                     throw;
    205                 }
     107                array_construct_noinit(memory, N);
     108                object = memory;
    206109            }
    207110            void operator()(const void*) {
    208                 destroy(N);
    209             }
    210         private:
    211             void destroy(std::size_t n) {
    212111                if (object) {
    213                     for (std::size_t i = n; i > 0; ) {
    214                         object[--i].~T();
    215                     }
     112                    array_destroy(object, N);
    216113                    object = 0;
    217114                }
    218115            }
     116        private:
    219117            T* object;
    220118        };
  • trunk/boost/smart_ptr/make_shared_array.hpp

    r81700 r81748  
    1414#include <boost/smart_ptr/detail/array_traits.hpp>
    1515#include <boost/smart_ptr/detail/make_array_helper.hpp>
    16 #include <boost/smart_ptr/detail/sp_forward.hpp>
    1716#include <boost/smart_ptr/detail/sp_if_array.hpp>
    1817#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
Note: See TracChangeset for help on using the changeset viewer.