diff options
author | Patrick Scott <phanna@android.com> | 2010-02-08 17:36:48 -0500 |
---|---|---|
committer | Patrick Scott <phanna@android.com> | 2010-02-16 12:26:42 -0500 |
commit | e46c9386c4f79aa40185f79a19fc5b2a7ef528b3 (patch) | |
tree | 785c28f10984b472887c005e796cabb001088770 /stlport/stl/_construct.h | |
parent | e64e7c849b0b659d3e198e4efaed563601e554be (diff) | |
download | stlport-e46c9386c4f79aa40185f79a19fc5b2a7ef528b3.tar.gz |
Update STLPort and compile the library
Turn on most features of stl and compile the source for streams.
Diffstat (limited to 'stlport/stl/_construct.h')
-rw-r--r-- | stlport/stl/_construct.h | 289 |
1 files changed, 289 insertions, 0 deletions
diff --git a/stlport/stl/_construct.h b/stlport/stl/_construct.h new file mode 100644 index 0000000..9361878 --- /dev/null +++ b/stlport/stl/_construct.h @@ -0,0 +1,289 @@ +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Copyright (c) 1997 + * Moscow Center for SPARC Technology + * + * Copyright (c) 1999 + * Boris Fomitchev + * + * This material is provided "as is", with absolutely no warranty expressed + * or implied. Any use is at your own risk. + * + * Permission to use or copy this software for any purpose is hereby granted + * without fee, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +/* NOTE: This is an internal header file, included by other STL headers. + * You should not attempt to use it directly. + */ + +#ifndef _STLP_INTERNAL_CONSTRUCT_H +#define _STLP_INTERNAL_CONSTRUCT_H + +#if !defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_INTERNAL_CSTRING) +# include <stl/_cstring.h> +#endif + +#ifndef _STLP_INTERNAL_NEW +# include <stl/_new.h> +#endif + +#ifndef _STLP_INTERNAL_ITERATOR_BASE_H +# include <stl/_iterator_base.h> +#endif + +#ifndef _STLP_TYPE_TRAITS_H +# include <stl/type_traits.h> +#endif + +#if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC) +# include <stl/_move_construct_fwk.h> +#endif + +_STLP_BEGIN_NAMESPACE + +template <class _Tp> +inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/) +{ __pointer->~_Tp(); } + +template <class _Tp> +inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {} + +template <class _Tp> +inline void _Destroy(_Tp* __pointer) { + typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; + __destroy_aux(__pointer, _Trivial_destructor()); +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset(__REINTERPRET_CAST(char*, __pointer), _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif +} + +template <class _Tp> +inline void _Destroy_Moved(_Tp* __pointer) { +#if !defined (_STLP_NO_MOVE_SEMANTIC) + typedef typename __move_traits<_Tp>::complete _Trivial_destructor; + __destroy_aux(__pointer, _Trivial_destructor()); +# if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__pointer, _STLP_SHRED_BYTE, sizeof(_Tp)); +# endif +#else + _Destroy(__pointer); +#endif +} + +#if defined (new) +# define _STLP_NEW_REDEFINE new +# undef new +#endif + +template <class _T1> +inline void _Construct_aux (_T1* __p, const __false_type&) { + new(__p) _T1(); +} + +template <class _T1> +inline void _Construct_aux (_T1* __p, const __true_type&) { +#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) + *__p = _T1(0); +#else + // We use binary copying for POD types since it results + // in a considerably better code at least on MSVC. + *__p = _T1(); +#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ +} + +template <class _T1> +inline void _Construct(_T1* __p) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif +#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG) + _Construct_aux (__p, _HasDefaultZeroValue(__p)._Answer()); +#else + _Construct_aux (__p, _Is_POD(__p)._Answer()); +#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */ +} + +template <class _Tp> +inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __false_type&) { + new(__p) _Tp(__val); +} + +template <class _Tp> +inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __true_type&) { + // We use binary copying for POD types since it results + // in a considerably better code at least on MSVC. + *__p = __val; +} + +template <class _Tp> +inline void _Copy_Construct(_Tp* __p, const _Tp& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif + _Copy_Construct_aux(__p, __val, _Is_POD(__p)._Answer()); +} + +template <class _T1, class _T2> +inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __false_type&) { + new(__p) _T1(__val); +} + +template <class _T1, class _T2> +inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) { + // We use binary copying for POD types since it results + // in a considerably better code at least on MSVC. + *__p = _T1(__val); +} + +template <class _T1, class _T2> +inline void _Param_Construct(_T1* __p, const _T2& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif + _Param_Construct_aux(__p, __val, _Is_POD(__p)._Answer()); +} + +template <class _T1, class _T2> +inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) { +#if !defined (_STLP_NO_MOVE_SEMANTIC) + new(__p) _T1(_STLP_PRIV _AsMoveSource(__val)); +#else + _Param_Construct(__p, __val); +#endif +} + +template <class _T1, class _T2> +inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) { + // We use binary copying for POD types since it results + // in a considerably better code at least on MSVC. + *__p = _T1(__val); +} + +template <class _T1, class _T2> +inline void _Move_Construct(_T1* __p, _T2& __val) { +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1)); +#endif + _Move_Construct_Aux(__p, __val, _Is_POD(__p)._Answer()); +} + +#if defined(_STLP_NEW_REDEFINE) +# if defined (DEBUG_NEW) +# define new DEBUG_NEW +# endif +# undef _STLP_NEW_REDEFINE +#endif + +template <class _ForwardIterator, class _Tp> +_STLP_INLINE_LOOP void +__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __false_type& /*_Trivial_destructor*/) { + for ( ; __first != __last; ++__first) { + __destroy_aux(&(*__first), __false_type()); +#if defined (_STLP_DEBUG_UNINITIALIZED) + memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); +#endif + } +} + +template <class _ForwardIterator, class _Tp> +#if defined (_STLP_DEBUG_UNINITIALIZED) +_STLP_INLINE_LOOP void +__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __true_type& /*_Trivial_destructor*/) { + for ( ; __first != __last; ++__first) + memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp)); +} +#else +inline void +__destroy_range_aux(_ForwardIterator, _ForwardIterator, _Tp*, const __true_type& /*_Trivial_destructor*/) {} +#endif + +template <class _ForwardIterator, class _Tp> +inline void +__destroy_range(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { + typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor; + __destroy_range_aux(__first, __last, __ptr, _Trivial_destructor()); +} + +template <class _ForwardIterator> +inline void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last) { + __destroy_range(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); +} + +inline void _Destroy_Range(char*, char*) {} +#if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97 +inline void _Destroy_Range(wchar_t*, wchar_t*) {} +inline void _Destroy_Range(const wchar_t*, const wchar_t*) {} +#endif + +#if !defined (_STLP_NO_MOVE_SEMANTIC) +template <class _ForwardIterator, class _Tp> +inline void +__destroy_mv_srcs(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) { + typedef typename __move_traits<_Tp>::complete _CompleteMove; + __destroy_range_aux(__first, __last, __ptr, _CompleteMove()); +} +#endif + +template <class _ForwardIterator> +inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last) +#if !defined (_STLP_NO_MOVE_SEMANTIC) +{ __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); } +#else +{ _Destroy_Range(__first, __last); } +#endif + +#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG) +// Those adaptors are here to fix common compiler bug regarding builtins: +// expressions like int k = int() should initialize k to 0 +template <class _Tp> +inline _Tp __default_constructed_aux(_Tp*, const __false_type&) { + return _Tp(); +} +template <class _Tp> +inline _Tp __default_constructed_aux(_Tp*, const __true_type&) { + return _Tp(0); +} + +template <class _Tp> +inline _Tp __default_constructed(_Tp* __p) { + return __default_constructed_aux(__p, _HasDefaultZeroValue(__p)._Answer()); +} + +# define _STLP_DEFAULT_CONSTRUCTED(_TTp) __default_constructed((_TTp*)0) +#else +# define _STLP_DEFAULT_CONSTRUCTED(_TTp) _TTp() +#endif /* _STLP_DEF_CONST_DEF_PARAM_BUG */ + + +#if !defined (_STLP_NO_ANACHRONISMS) +// -------------------------------------------------- +// Old names from the HP STL. + +template <class _T1, class _T2> +inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); } +template <class _T1> +inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); } +template <class _Tp> +inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); } +template <class _ForwardIterator> +inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { _STLP_STD::_Destroy_Range(__first, __last); } +#endif /* _STLP_NO_ANACHRONISMS */ + +_STLP_END_NAMESPACE + +#endif /* _STLP_INTERNAL_CONSTRUCT_H */ + +// Local Variables: +// mode:C++ +// End: |