ossrv_pub/boost_apis/boost/scoped_array.hpp
changeset 31 ce057bb09d0b
parent 0 e4d67989cc36
equal deleted inserted replaced
30:e20de85af2ee 31:ce057bb09d0b
       
     1 #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
       
     2 #define BOOST_SCOPED_ARRAY_HPP_INCLUDED
       
     3 
       
     4 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
       
     5 //  Copyright (c) 2001, 2002 Peter Dimov
       
     6 //
       
     7 //  Distributed under the Boost Software License, Version 1.0. (See
       
     8 //  accompanying file LICENSE_1_0.txt or copy at
       
     9 //  http://www.boost.org/LICENSE_1_0.txt)
       
    10 //
       
    11 //  http://www.boost.org/libs/smart_ptr/scoped_array.htm
       
    12 //
       
    13 
       
    14 #include <boost/assert.hpp>
       
    15 #include <boost/checked_delete.hpp>
       
    16 #include <boost/config.hpp>   // in case ptrdiff_t not in std
       
    17 
       
    18 #include <boost/detail/workaround.hpp>
       
    19 
       
    20 #include <cstddef>            // for std::ptrdiff_t
       
    21 
       
    22 namespace boost
       
    23 {
       
    24 
       
    25 // Debug hooks
       
    26 
       
    27 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
       
    28 
       
    29 void sp_array_constructor_hook(void * p);
       
    30 void sp_array_destructor_hook(void * p);
       
    31 
       
    32 #endif
       
    33 
       
    34 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
       
    35 //  is guaranteed, either on destruction of the scoped_array or via an explicit
       
    36 //  reset(). Use shared_array or std::vector if your needs are more complex.
       
    37 
       
    38 template<class T> class scoped_array // noncopyable
       
    39 {
       
    40 private:
       
    41 
       
    42     T * ptr;
       
    43 
       
    44     scoped_array(scoped_array const &);
       
    45     scoped_array & operator=(scoped_array const &);
       
    46 
       
    47     typedef scoped_array<T> this_type;
       
    48 
       
    49 public:
       
    50 
       
    51     typedef T element_type;
       
    52 
       
    53     explicit scoped_array(T * p = 0) : ptr(p) // never throws
       
    54     {
       
    55 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
       
    56         boost::sp_array_constructor_hook(ptr);
       
    57 #endif
       
    58     }
       
    59 
       
    60     ~scoped_array() // never throws
       
    61     {
       
    62 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
       
    63         boost::sp_array_destructor_hook(ptr);
       
    64 #endif
       
    65         boost::checked_array_delete(ptr);
       
    66     }
       
    67 
       
    68     void reset(T * p = 0) // never throws
       
    69     {
       
    70         BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors
       
    71         this_type(p).swap(*this);
       
    72     }
       
    73 
       
    74     T & operator[](std::ptrdiff_t i) const // never throws
       
    75     {
       
    76         BOOST_ASSERT(ptr != 0);
       
    77         BOOST_ASSERT(i >= 0);
       
    78         return ptr[i];
       
    79     }
       
    80 
       
    81     T * get() const // never throws
       
    82     {
       
    83         return ptr;
       
    84     }
       
    85 
       
    86     // implicit conversion to "bool"
       
    87 
       
    88 #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
       
    89 
       
    90     operator bool () const
       
    91     {
       
    92         return ptr != 0;
       
    93     }
       
    94 
       
    95 #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
       
    96     typedef T * (this_type::*unspecified_bool_type)() const;
       
    97     
       
    98     operator unspecified_bool_type() const // never throws
       
    99     {
       
   100         return ptr == 0? 0: &this_type::get;
       
   101     }
       
   102 
       
   103 #else 
       
   104 
       
   105     typedef T * this_type::*unspecified_bool_type;
       
   106 
       
   107     operator unspecified_bool_type() const // never throws
       
   108     {
       
   109         return ptr == 0? 0: &this_type::ptr;
       
   110     }
       
   111 
       
   112 #endif
       
   113 
       
   114     bool operator! () const // never throws
       
   115     {
       
   116         return ptr == 0;
       
   117     }
       
   118 
       
   119     void swap(scoped_array & b) // never throws
       
   120     {
       
   121         T * tmp = b.ptr;
       
   122         b.ptr = ptr;
       
   123         ptr = tmp;
       
   124     }
       
   125 
       
   126 };
       
   127 
       
   128 template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
       
   129 {
       
   130     a.swap(b);
       
   131 }
       
   132 
       
   133 } // namespace boost
       
   134 
       
   135 #endif  // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED