extl/smartptr/shared_array.h

   1 /* ///////////////////////////////////////////////////////////////////////
   2  * File:                shared_array.h
   3  *
   4  * Created:             08.02.25
   5  * Updated:             08.05.06
   6  *
   7  * Brief: shared_array class - shared array
   8  *
   9  * [<Home>]
  10  * Copyright (c) 2008-2020, Waruqi All rights reserved.
  11  * //////////////////////////////////////////////////////////////////// */
  12 #ifndef EXTL_SMART_PTR_SHARED_ARRAY_H
  13 #define EXTL_SMART_PTR_SHARED_ARRAY_H
  14
  15 /*!\file shared_array.h
  16  * \brief shared_array class - shared array
  17  *
  18  * - custom thread-safe reference count
  19  * - safe implicit conversion to the bool type
  20  * - custom deleter
  21  *   - default deleter: new_allocator<T>::array_deleter_type
  22  *   - custom deleter function object:
  23  *     struct deleter
  24  *     {
  25  *         void operator()(int *p)
  26  *         {
  27  *           delete[] p;
  28  *         }
  29  *     };
  30  *   - usage:
  31  *     - shared_array<int, deleter > p(new int[10]); - using default deleter
  32  *     - shared_array<int, deleter > p(new int[10], deleter());
  33  *     - shared_array<int, deleter > p(new int[10], deleter(...));
  34  *
  35  */
  36 #ifndef __cplusplus
  37 #       error shared_array.h need be supported by c++.
  38 #endif
  39
  40 /* ///////////////////////////////////////////////////////////////////////
  41  * Includes
  42  */
  43 #include "prefix.h"
  44 #include "../utility/operator_bool.h"
  45 #include "../algorithm/algorithm.h" /* for std_swap */
  46 #include "../counter/shared_counter.h"
  47 #include "../memory/allocator_selector.h"
  48
  49 /* ///////////////////////////////////////////////////////////////////////
  50  * Warnings
  51  */
  52 #if defined(EXTL_COMPILER_IS_MSVC) && (_MSC_VER <= 1200)
  53 #       pragma warning(push)
  54 #       pragma warning(disable:4284) /* odd return type for operator-> */
  55 #endif
  56
  57 /* ///////////////////////////////////////////////////////////////////////
  58  * ::extl namespace
  59  */
  60 EXTL_BEGIN_NAMESPACE
  61
  62 /*!\brief shared_array class
  63  *
  64  * \param T The value type
  65  * \param D The deleter type
  66  *
  67  * \ingroup extl_group_smart_ptr
  68  */
  69 template<       typename_param_k T
  70         #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
  71                 ,       typename_param_k D = typename_type_def_k new_allocator<T>::array_deleter_type
  72         #else
  73                 ,       typename_param_k D
  74         #endif
  75                 >
  76 class shared_array
  77 {
  78         /// \name Types
  79         /// @{
  80         public:
  81                 typedef shared_array<T, D>                                                              class_type;
  82                 typedef T                                                                                               value_type;
  83                 typedef value_type*                                                                             pointer;
  84                 typedef value_type const*                                                               const_pointer;
  85                 typedef value_type&                                                                             reference;
  86                 typedef value_type const&                                                               const_reference;
  87                 typedef e_long_t                                                                                index_type;
  88                 typedef D                                                                                               deleter_type;
  89
  90         #ifdef EXTL_TEMPLATE_CLASS_DEFAULT_ARGUMENT_SUPPORT
  91                 typedef shared_counter< value_type, deleter_type >              shared_counter_type;
  92         #else
  93                 typedef shared_counter  <       value_type
  94                                                                 ,       deleter_type
  95                                                                 ,       typename_type_k synch_traits_selector::synch_traits_type
  96                                                                 ,       typename_type_k allocator_selector<     e_byte_t >::allocator_type
  97                                                                 >                                                               shared_counter_type;
  98         #endif
  99                 typedef typename_type_k shared_counter_type::size_type  size_type;
 100         /// @}
 101
 102         /// \name Members
 103         /// @{
 104         private:
 105                 pointer                                                                                                 m_ptr;
 106                 shared_counter_type                                                                             m_shared_counter;
 107         /// @}
 108
 109         /// \name Constructors
 110         /// @{
 111         public:
 112                 /* Constructor and destructor */
 113                 shared_array()
 114                         : m_ptr(NULL), m_shared_counter()
 115                 {
 116                 }
 117
 118                 explicit_k shared_array(pointer p)
 119                         : m_ptr(p), m_shared_counter(p)
 120                 {
 121                         EXTL_ASSERT(is_valid());
 122                 }
 123
 124                 shared_array(pointer p, deleter_type const& del)
 125                         : m_ptr(p), m_shared_counter(p, del)
 126                 {
 127                         EXTL_ASSERT(is_valid());
 128                 }
 129
 130                 shared_array(class_type const& rhs)
 131                         : m_ptr(rhs.m_ptr), m_shared_counter(rhs.m_shared_counter)
 132                 {
 133                         EXTL_ASSERT(is_valid());
 134                 }
 135                 ~shared_array() EXTL_THROW_0()
 136                 {
 137                 }
 138         #ifdef EXTL_MEMBER_TEMPLATE_CTOR_OVERLOAD_DISCRIMINATED_SUPPORT
 139                 template < typename_param_k T1 >
 140                 explicit_k shared_array(T1* p)
 141                         : m_ptr(p), m_shared_counter(p)
 142                 {
 143                         EXTL_ASSERT(is_valid());
 144                 }
 145
 146                 template < typename_param_k T1, typename_param_k D1 >
 147                 shared_array(shared_array<T1, D1> const& rhs)
 148                         : m_ptr(rhs.m_ptr), m_shared_counter(rhs.m_shared_counter)
 149                 {
 150                         EXTL_ASSERT(is_valid());
 151                 }
 152         #endif
 153         /// @}
 154
 155         public:
 156                 /// operator=() overload
 157                 class_type& operator=(class_type const& rhs)
 158                 {
 159                         EXTL_ASSERT(is_valid());
 160                         if(this != &rhs) /* Prevent self-assigment */
 161                         {
 162                                 m_ptr = rhs.m_ptr;
 163                                 m_shared_counter = rhs.m_shared_counter;
 164                         }
 165                         EXTL_ASSERT(is_valid());
 166                         return *this;
 167                 }
 168         #ifdef EXTL_MEMBER_TEMPLATE_FUNC_OVERLOAD_DISCRIMINATED_SUPPORT
 169                 /// operator=() overload
 170                 template < typename_param_k T1, typename_param_k D1 >
 171                 class_type& operator=(shared_array<T1, D1> const& rhs)
 172                 {
 173                         EXTL_ASSERT(is_valid());
 174                         if(this != &rhs) /* Prevent self-assigment */
 175                         {
 176                                 m_ptr = rhs.m_ptr;
 177                                 m_shared_counter = rhs.m_shared_counter;
 178                         }
 179                         EXTL_ASSERT(is_valid());
 180                         return *this;
 181                 }
 182         #endif
 183
 184         /// \name Accessors
 185         /// @{
 186         public:
 187                 reference operator[](index_type const& index) const
 188                 {
 189                         EXTL_ASSERT(NULL != m_ptr);
 190                         EXTL_ASSERT(index >= 0);
 191                         EXTL_ASSERT(is_valid());
 192
 193                         return m_ptr[index];
 194                 }
 195                 const_pointer get_ptr() const
 196                 {
 197                         EXTL_ASSERT(is_valid());
 198                         return m_ptr;
 199                 }
 200
 201                 pointer get_ptr()
 202                 {
 203                         EXTL_ASSERT(is_valid());
 204                         return m_ptr;
 205                 }
 206                 /* Returns the reference count */
 207                 size_type count() const
 208                 {
 209                         EXTL_ASSERT(is_valid());
 210                         return m_shared_counter.count();
 211                 }
 212                 e_bool_t is_unique() const
 213                 {
 214                         return m_shared_counter.is_unique();
 215                 }
 216         /// @}
 217
 218         /// \name Mutators
 219         /// @{
 220         public:
 221                 /* swap */
 222                 void swap(class_type& other)
 223                 {
 224                         EXTL_ASSERT(is_valid());
 225                         std_swap(m_ptr, other.m_ptr);
 226                         m_shared_counter.swap(other.m_shared_counter);
 227                         EXTL_ASSERT(is_valid());
 228                 }
 229         #ifdef EXTL_MEMBER_TEMPLATE_FUNC_OVERLOAD_DISCRIMINATED_SUPPORT
 230                 template < typename_param_k T1, typename_param_k D1 >
 231                 void swap(shared_array<T1, D1>& other)
 232                 {
 233                         EXTL_ASSERT(is_valid());
 234                         std_swap(m_ptr, other.m_ptr);
 235                         m_shared_counter.swap(other.m_shared_counter);
 236                         EXTL_ASSERT(is_valid());
 237                 }
 238         #endif
 239
 240                 /* Reset the pointer */
 241                 void reset()
 242                 {
 243                         class_type().swap(*this);
 244                 }
 245                 void reset(pointer p)
 246                 {
 247                         EXTL_ASSERT(p != m_ptr);
 248                         class_type(p).swap(*this);
 249                 }
 250
 251         #ifdef EXTL_MEMBER_TEMPLATE_FUNC_OVERLOAD_DISCRIMINATED_SUPPORT
 252                 template < typename_param_k T1 >
 253                 void reset(T1* p)
 254                 {
 255                         EXTL_ASSERT(p != m_ptr);
 256                         class_type(p).swap(*this);
 257                 }
 258         #endif
 259         /// @}
 260
 261         public:
 262                 /// safe implicit conversion to the bool type
 263                 EXTL_OPERATOR_BOOL_DEFINE_TYPE_T(class_type, safe_bool_type);
 264                 operator safe_bool_type() const
 265                 {
 266                         return EXTL_OPERATOR_BOOL_RETURN_RESULT(m_ptr != NULL);
 267                 }
 268
 269                 e_bool_t operator !() const                                                     { return (m_ptr == NULL);       }
 270
 271                 /// less than
 272                 e_bool_t lt(class_type const & rhs) const                       { return m_ptr < rhs.m_ptr;     }
 273         #ifdef EXTL_MEMBER_TEMPLATE_FUNC_OVERLOAD_DISCRIMINATED_SUPPORT
 274                 /// less than
 275                 template < typename_param_k T1, typename_param_k D1 >
 276                 e_bool_t lt(shared_array<T1, D1> const & rhs) const     { return m_ptr < rhs.m_ptr;     }
 277         #endif
 278
 279         private:
 280                 inline e_bool_t is_valid() const
 281                 {
 282                         if((NULL == m_ptr) != m_shared_counter.is_zero())
 283                         {
 284                                 return e_false_v;
 285                         }
 286                         if((NULL != m_ptr) && (m_shared_counter.count() < 1))
 287                         {
 288                                 return e_false_v;
 289                         }
 290                         return e_true_v;
 291                 }
 292 };
 293
 294 /* ///////////////////////////////////////////////////////////////////////
 295  * Operators overload
 296  */
 297 template< typename_param_k T, typename_param_k D >
 298 inline e_bool_t operator==(shared_array<T, D> const& lhs, shared_array<T, D> const& rhs)
 299 {
 300     return lhs.get_ptr() == rhs.get_ptr();
 301 }
 302
 303 template< typename_param_k T, typename_param_k D >
 304 inline e_bool_t operator!=(shared_array<T, D> const& lhs, shared_array<T, D> const& rhs)
 305 {
 306     return lhs.get_ptr() != rhs.get_ptr();
 307 }
 308
 309 /* VC6.0: p != NULL */
 310 #if defined(EXTL_COMPILER_IS_MSVC) && (_MSC_VER == 1200)
 311 template< typename_param_k T, typename_param_k D >
 312 inline e_bool_t operator==(shared_array<T, D> const& lhs, void* rhs)
 313 {
 314     return lhs.get_ptr() == static_cast<T*>(rhs);
 315 }
 316
 317 template< typename_param_k T, typename_param_k D >
 318 inline e_bool_t operator!=(shared_array<T, D> const& lhs, void* rhs)
 319 {
 320     return lhs.get_ptr() != static_cast<T*>(rhs);
 321 }
 322 #endif
 323
 324 template< typename_param_k T, typename_param_k D >
 325 inline e_bool_t operator<(shared_array<T, D> const& lhs, shared_array<T, D> const& rhs)
 326 {
 327     return lhs.lt(rhs);
 328 }
 329 /// swap
 330 template< typename_param_k T, typename_param_k D >
 331 inline void swap(shared_array<T, D>& lhs, shared_array<T, D>& rhs)
 332 {
 333     lhs.swap(rhs);
 334 }
 335 /// get pointer shim
 336 template< typename_param_k T, typename_param_k D >
 337 inline T const* get_ptr(shared_array<T, D> const& p)
 338 {
 339     return p.get_ptr();
 340 }
 341
 342 /* ///////////////////////////////////////////////////////////////////////
 343  * Unit-testing
 344  */
 345 #ifdef EXTL_SHARED_ARRAY_TEST_ENABLE
 346 #       include "unit_test/shared_array_test.h"
 347 #endif
 348
 349 /* ///////////////////////////////////////////////////////////////////////
 350  * ::extl namespace
 351  */
 352 EXTL_END_NAMESPACE
 353
 354 /* ///////////////////////////////////////////////////////////////////////
 355  * Warnings
 356  */
 357 #if defined(EXTL_COMPILER_IS_MSVC) && (_MSC_VER <= 1200)
 358 #       pragma warning(pop)
 359 #endif
 360
 361 /* ///////////////////////////////////////////////////////////////////////
 362  * std::swap
 363  */
 364 #if !defined(EXTL_NO_STL) && \
 365                 !defined(EXTL_NO_NAMESPACE)
 366 /* ::std namespace */
 367 EXTL_STD_BEGIN_NAMESPACE
 368
 369 template< typename_param_k T, typename_param_k D >
 370 inline void swap(EXTL_NS(shared_array)<T, D>& lhs, EXTL_NS(shared_array)<T, D>& rhs)
 371 {
 372     lhs.swap(rhs);
 373 }
 374 /* ::std namespace */
 375 EXTL_STD_END_NAMESPACE
 376 #endif
 377
 378 /* //////////////////////////////////////////////////////////////////// */
 379 #endif /* EXTL_SMART_PTR_SHARED_ARRAY_H */
 380 /* //////////////////////////////////////////////////////////////////// */
 381