1/* 2 * 3 * Copyright (c) 1994 4 * Hewlett-Packard Company 5 * 6 * Copyright (c) 1996,1997 7 * Silicon Graphics Computer Systems, Inc. 8 * 9 * Copyright (c) 1997 10 * Moscow Center for SPARC Technology 11 * 12 * Copyright (c) 1999 13 * Boris Fomitchev 14 * 15 * This material is provided "as is", with absolutely no warranty expressed 16 * or implied. Any use is at your own risk. 17 * 18 * Permission to use or copy this software for any purpose is hereby granted 19 * without fee, provided the above notices are retained on all copies. 20 * Permission to modify the code and to distribute modified code is granted, 21 * provided the above notices are retained, and a notice that the code was 22 * modified is included with the above copyright notice. 23 * 24 */ 25 26/* NOTE: This is an internal header file, included by other STL headers. 27 * You should not attempt to use it directly. 28 */ 29 30#ifndef _STLP_INTERNAL_CONSTRUCT_H 31#define _STLP_INTERNAL_CONSTRUCT_H 32 33#if !defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_INTERNAL_CSTRING) 34# include <stl/_cstring.h> 35#endif 36 37#ifndef _STLP_INTERNAL_NEW 38# include <stl/_new.h> 39#endif 40 41#ifndef _STLP_INTERNAL_ITERATOR_BASE_H 42# include <stl/_iterator_base.h> 43#endif 44 45#ifndef _STLP_TYPE_TRAITS_H 46# include <stl/type_traits.h> 47#endif 48 49#if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC) 50# include <stl/_move_construct_fwk.h> 51#endif 52 53_STLP_BEGIN_NAMESPACE 54 55template <class _Tp> 56inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/) 57{ __pointer->~_Tp(); } 58 59template <class _Tp> 60inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {} 61 62template <class _Tp> 63inline void _Destroy(_Tp* __pointer) { 64 typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; 65 __destroy_aux(__pointer, _Trivial_destructor()); 66#if defined (_STLP_DEBUG_UNINITIALIZED) 67 memset(__REINTERPRET_CAST(char*, __pointer), _STLP_SHRED_BYTE, sizeof(_Tp)); 68#endif 69} 70 71template <class _Tp> 72inline void _Destroy_Moved(_Tp* __pointer) { 73#if !defined (_STLP_NO_MOVE_SEMANTIC) 74 typedef typename __move_traits<_Tp>::complete _Trivial_destructor; 75 __destroy_aux(__pointer, _Trivial_destructor()); 76# if defined (_STLP_DEBUG_UNINITIALIZED) 77 memset((char*)__pointer, _STLP_SHRED_BYTE, sizeof(_Tp)); 78# endif 79#else 80 _Destroy(__pointer); 81#endif 82} 83 84#if defined (new) 85# define _STLP_NEW_REDEFINE new 86# undef new 87#endif 88 89template <class _T1> 90inline void _Construct_aux (_T1* __p, const __false_type&) { 91 new(__p) _T1(); 92} 93 94template <class _T1> 95inline void _Construct_aux (_T1* __p, const __true_type&) { 96#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) 97 *__p = _T1(0); 98#else 99 // We use binary copying for POD types since it results 100 // in a considerably better code at least on MSVC. 101 *__p = _T1(); 102#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ 103} 104 105template <class _T1> 106inline void _Construct(_T1* __p) { 107#if defined (_STLP_DEBUG_UNINITIALIZED) 108 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); 109#endif 110#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) 111 _Construct_aux (__p, _HasDefaultZeroValue(__p)._Answer()); 112#else 113 _Construct_aux (__p, _Is_POD(__p)._Answer()); 114#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ 115} 116 117template <class _Tp> 118inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __false_type&) { 119 new(__p) _Tp(__val); 120} 121 122template <class _Tp> 123inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __true_type&) { 124 // We use binary copying for POD types since it results 125 // in a considerably better code at least on MSVC. 126 *__p = __val; 127} 128 129template <class _Tp> 130inline void _Copy_Construct(_Tp* __p, const _Tp& __val) { 131#if defined (_STLP_DEBUG_UNINITIALIZED) 132 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp)); 133#endif 134 _Copy_Construct_aux(__p, __val, _Is_POD(__p)._Answer()); 135} 136 137template <class _T1, class _T2> 138inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __false_type&) { 139 new(__p) _T1(__val); 140} 141 142template <class _T1, class _T2> 143inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) { 144 // We use binary copying for POD types since it results 145 // in a considerably better code at least on MSVC. 146 *__p = _T1(__val); 147} 148 149template <class _T1, class _T2> 150inline void _Param_Construct(_T1* __p, const _T2& __val) { 151#if defined (_STLP_DEBUG_UNINITIALIZED) 152 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); 153#endif 154 _Param_Construct_aux(__p, __val, _Is_POD(__p)._Answer()); 155} 156 157template <class _T1, class _T2> 158inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) { 159#if !defined (_STLP_NO_MOVE_SEMANTIC) 160 new(__p) _T1(_STLP_PRIV _AsMoveSource(__val)); 161#else 162 _Param_Construct(__p, __val); 163#endif 164} 165 166template <class _T1, class _T2> 167inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) { 168 // We use binary copying for POD types since it results 169 // in a considerably better code at least on MSVC. 170 *__p = _T1(__val); 171} 172 173template <class _T1, class _T2> 174inline void _Move_Construct(_T1* __p, _T2& __val) { 175#if defined (_STLP_DEBUG_UNINITIALIZED) 176 memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); 177#endif 178 _Move_Construct_Aux(__p, __val, _Is_POD(__p)._Answer()); 179} 180 181#if defined(_STLP_NEW_REDEFINE) 182# if defined (DEBUG_NEW) 183# define new DEBUG_NEW 184# endif 185# undef _STLP_NEW_REDEFINE 186#endif 187 188template <class _ForwardIterator, class _Tp> 189_STLP_INLINE_LOOP void 190__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __false_type& /*_Trivial_destructor*/) { 191 for ( ; __first != __last; ++__first) { 192 __destroy_aux(&(*__first), __false_type()); 193#if defined (_STLP_DEBUG_UNINITIALIZED) 194 memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); 195#endif 196 } 197} 198 199template <class _ForwardIterator, class _Tp> 200#if defined (_STLP_DEBUG_UNINITIALIZED) 201_STLP_INLINE_LOOP void 202__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __true_type& /*_Trivial_destructor*/) { 203 for ( ; __first != __last; ++__first) 204 memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); 205} 206#else 207inline void 208__destroy_range_aux(_ForwardIterator, _ForwardIterator, _Tp*, const __true_type& /*_Trivial_destructor*/) {} 209#endif 210 211template <class _ForwardIterator, class _Tp> 212inline void 213__destroy_range(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { 214 typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; 215 __destroy_range_aux(__first, __last, __ptr, _Trivial_destructor()); 216} 217 218template <class _ForwardIterator> 219inline void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last) { 220 __destroy_range(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); 221} 222 223inline void _Destroy_Range(char*, char*) {} 224#if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97 225inline void _Destroy_Range(wchar_t*, wchar_t*) {} 226inline void _Destroy_Range(const wchar_t*, const wchar_t*) {} 227#endif 228 229#if !defined (_STLP_NO_MOVE_SEMANTIC) 230template <class _ForwardIterator, class _Tp> 231inline void 232__destroy_mv_srcs(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { 233 typedef typename __move_traits<_Tp>::complete _CompleteMove; 234 __destroy_range_aux(__first, __last, __ptr, _CompleteMove()); 235} 236#endif 237 238template <class _ForwardIterator> 239inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last) 240#if !defined (_STLP_NO_MOVE_SEMANTIC) 241{ __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); } 242#else 243{ _Destroy_Range(__first, __last); } 244#endif 245 246#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG) 247// Those adaptors are here to fix common compiler bug regarding builtins: 248// expressions like int k = int() should initialize k to 0 249template <class _Tp> 250inline _Tp __default_constructed_aux(_Tp*, const __false_type&) { 251 return _Tp(); 252} 253template <class _Tp> 254inline _Tp __default_constructed_aux(_Tp*, const __true_type&) { 255 return _Tp(0); 256} 257 258template <class _Tp> 259inline _Tp __default_constructed(_Tp* __p) { 260 return __default_constructed_aux(__p, _HasDefaultZeroValue(__p)._Answer()); 261} 262 263# define _STLP_DEFAULT_CONSTRUCTED(_TTp) __default_constructed((_TTp*)0) 264#else 265# define _STLP_DEFAULT_CONSTRUCTED(_TTp) _TTp() 266#endif /* _STLP_DEF_CONST_DEF_PARAM_BUG */ 267 268 269#if !defined (_STLP_NO_ANACHRONISMS) 270// -------------------------------------------------- 271// Old names from the HP STL. 272 273template <class _T1, class _T2> 274inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); } 275template <class _T1> 276inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); } 277template <class _Tp> 278inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); } 279template <class _ForwardIterator> 280inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { _STLP_STD::_Destroy_Range(__first, __last); } 281#endif /* _STLP_NO_ANACHRONISMS */ 282 283_STLP_END_NAMESPACE 284 285#endif /* _STLP_INTERNAL_CONSTRUCT_H */ 286 287// Local Variables: 288// mode:C++ 289// End: 290