diff options
Diffstat (limited to 'WebKit/android/stlport/stl/pointers')
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_deque.h | 379 | ||||
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_list.h | 337 | ||||
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_set.h | 536 | ||||
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_slist.h | 413 | ||||
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_tools.h | 400 | ||||
| -rw-r--r-- | WebKit/android/stlport/stl/pointers/_vector.h | 238 |
6 files changed, 2303 insertions, 0 deletions
diff --git a/WebKit/android/stlport/stl/pointers/_deque.h b/WebKit/android/stlport/stl/pointers/_deque.h new file mode 100644 index 0000000..a2c2774 --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_deque.h @@ -0,0 +1,379 @@ +/* + * Copyright (c) 2004 + * Francois Dumont + * + * 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_SPECIALIZED_DEQUE_H +#define _STLP_SPECIALIZED_DEQUE_H + +#ifndef _STLP_POINTERS_SPEC_TOOLS_H +# include <stl/pointers/_tools.h> +#endif + +_STLP_BEGIN_NAMESPACE +_STLP_MOVE_TO_PRIV_NAMESPACE + +/* + * struct helper to cast deque iterators: + */ +template <class _StorageT, class _ValueT> +struct _DequeIteCast { + typedef _Deque_iterator<_ValueT, _Nonconst_traits<_ValueT> > iterator; + typedef _Deque_iterator<_ValueT, _Const_traits<_ValueT> > const_iterator; + typedef _Deque_iterator<_StorageT, _Nonconst_traits<_StorageT> > storage_iterator; + typedef _Deque_iterator<_StorageT, _Const_traits<_StorageT> > const_storage_iterator; + typedef _CastTraits<_StorageT, _ValueT> cast_traits; + + static iterator to_value_type_ite (storage_iterator const& __ite) { + iterator tmp; + tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur); + tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first); + tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last); + tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node); + return tmp; + } + static storage_iterator to_storage_type_ite (iterator const& __ite) { + storage_iterator tmp; + tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur); + tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first); + tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last); + tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node); + return tmp; + } + + static const_iterator to_value_type_cite (const_storage_iterator const& __ite) { + const_iterator tmp; + tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur); + tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first); + tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last); + tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node); + return tmp; + } + + static const_storage_iterator to_storage_type_cite (const_iterator const& __ite) { + const_storage_iterator tmp; + tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur); + tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first); + tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last); + tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node); + return tmp; + } +}; + +#define DEQUE_IMPL _STLP_PTR_IMPL_NAME(deque) + +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<size_t, void*, allocator<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void***, void**, allocator<void**> >; +_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC _Deque_iterator<void*, _Nonconst_traits<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS _Deque_base<void*,allocator<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS DEQUE_IMPL<void*,allocator<void*> >; +#endif + +#if defined (_STLP_DEBUG) +# define deque _STLP_NON_DBG_NAME(deque) +#else +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) > +class deque +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque) + : public __stlport_class<deque<_Tp, _Alloc> > +#endif +{ + typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType; + typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV DEQUE_IMPL<_StorageType, _StorageTypeAlloc> _Base; + typedef deque<_Tp, _Alloc> _Self; + + typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits; + typedef _STLP_PRIV _DequeIteCast<_StorageType, _Tp> ite_cast_traits; + +public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef random_access_iterator_tag _Iterator_category; + _STLP_FORCE_ALLOCATORS(value_type, _Alloc) + typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type; + typedef _STLP_PRIV _Deque_iterator<value_type, _Nonconst_traits<value_type> > iterator; + typedef _STLP_PRIV _Deque_iterator<value_type, _Const_traits<value_type> > const_iterator; + + _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS; + +public: // Basic accessors + iterator begin() { return ite_cast_traits::to_value_type_ite(_M_impl.begin()); } + iterator end() { return ite_cast_traits::to_value_type_ite(_M_impl.end()); } + const_iterator begin() const { return ite_cast_traits::to_value_type_cite(_M_impl.begin()); } + const_iterator end() const { return ite_cast_traits::to_value_type_cite(_M_impl.end()); } + + reverse_iterator rbegin() { return reverse_iterator(end()); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rbegin() const + { return const_reverse_iterator(end()); } + const_reverse_iterator rend() const + { return const_reverse_iterator(begin()); } + + reference operator[](size_type __n) + { return cast_traits::to_value_type_ref(_M_impl[__n]); } + const_reference operator[](size_type __n) const + { return cast_traits::to_value_type_cref(_M_impl[__n]); } + + reference at(size_type __n) + { return cast_traits::to_value_type_ref(_M_impl.at(__n)); } + const_reference at(size_type __n) const + { return cast_traits::to_value_type_cref(_M_impl.at(__n)); } + + reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); } + reference back() { return cast_traits::to_value_type_ref(_M_impl.back()); } + const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); } + const_reference back() const { return cast_traits::to_value_type_cref(_M_impl.back()); } + + size_type size() const { return _M_impl.size(); } + size_type max_size() const { return _M_impl.max_size(); } + bool empty() const { return _M_impl.empty(); } + allocator_type get_allocator() const { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); } + + explicit deque(const allocator_type& __a = allocator_type()) + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + + deque(const _Self& __x) : _M_impl(__x._M_impl) {} + +#if !defined (_STLP_DONT_SUP_DFLT_PARAM) + explicit deque(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type), +#else + deque(size_type __n, const value_type& __val, +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + const allocator_type& __a = allocator_type()) + : _M_impl(__n, cast_traits::to_storage_type_cref(__val), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + // int,long variants may be needed +#if defined (_STLP_DONT_SUP_DFLT_PARAM) + explicit deque(size_type __n) : _M_impl(__n) {} +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + deque(_InputIterator __first, _InputIterator __last, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) +#if !defined (_STLP_USE_ITERATOR_WRAPPER) + : _M_impl(__first, __last, + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) { +#else + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) { +#endif +#if defined (_STLP_USE_ITERATOR_WRAPPER) + insert(end(), __first, __last); +#endif + } + +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + template <class _InputIterator> + deque(_InputIterator __first, _InputIterator __last) +# if !defined (_STLP_USE_ITERATOR_WRAPPER) + : _M_impl(__first, __last) {} +# else + { insert(end(), __first, __last); } +# endif +# endif + +#else + deque(const_pointer __first, const_pointer __last, + const allocator_type& __a = allocator_type() ) + : _M_impl(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + + deque(const_iterator __first, const_iterator __last, + const allocator_type& __a = allocator_type() ) + : _M_impl(ite_cast_traits::to_storage_type_cite(__first), + ite_cast_traits::to_storage_type_cite(__last), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} +#endif /* _STLP_MEMBER_TEMPLATES */ + + deque(__move_source<_Self> src) + : _M_impl(__move_source<_Base>(src.get()._M_impl)) {} + + _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; } + + void swap(_Self& __x) { _M_impl.swap(__x._M_impl); } + + void assign(size_type __n, const value_type& __val) { + _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); + } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_assign_dispatch(_Integer __n, _Integer __val, + const __true_type&) + { _M_impl.assign(__n, __val); } + + template <class _InputIterator> + void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + template <class _InputIterator> + void assign(_InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_assign_dispatch(__first, __last, _Integral()); +# else + _M_impl.assign(__first, __last); +# endif + } +#else + void assign(const_pointer __first, const_pointer __last) + { _M_impl.assign(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); } + void assign(const_iterator __first, const_iterator __last) + { _M_impl.assign(ite_cast_traits::to_storage_type_cite(__first), + ite_cast_traits::to_storage_type_cite(__last)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + +#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void push_back(const value_type& __t) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { _M_impl.push_back(cast_traits::to_storage_type_cref(__t)); } + +#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void push_front(const value_type& __t) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { _M_impl.push_front(cast_traits::to_storage_type_cref(__t)); } + +# if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + void push_back() { _M_impl.push_back(); } + void push_front() { _M_impl.push_front(); } +# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + + void pop_back() { _M_impl.pop_back(); } + void pop_front() { _M_impl.pop_front(); } + +#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + iterator insert(iterator __pos, const value_type& __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { return ite_cast_traits::to_value_type_ite(_M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), + cast_traits::to_storage_type_cref(__x))); } + +#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(value_type)); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + + void insert(iterator __pos, size_type __n, const value_type& __x) + { _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, cast_traits::to_storage_type_cref(__x)); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + const __true_type&) { + _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, __val); + } + + template <class _InputIterator> + void _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); +# else + _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __first, __last); +# endif + } + +#else /* _STLP_MEMBER_TEMPLATES */ + void insert(iterator __pos, + const_pointer __first, const_pointer __last) { + _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), + cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + void insert(iterator __pos, + const_iterator __first, const_iterator __last) { + _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), + ite_cast_traits::to_storage_type_cite(__first), + ite_cast_traits::to_storage_type_cite(__last)); + } + +#endif /* _STLP_MEMBER_TEMPLATES */ + +#if !defined (_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void resize(size_type __new_size, const value_type& __x) +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); } + +#if defined (_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size) { _M_impl.resize(__new_size); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + iterator erase(iterator __pos) + { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__pos))); } + + iterator erase(iterator __first, iterator __last) + { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__first), + ite_cast_traits::to_storage_type_ite(__last))); } + void clear() { _M_impl.clear(); } + +private: + _Base _M_impl; +}; + +#if defined (deque) +# undef deque +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#undef DEQUE_IMPL + +_STLP_END_NAMESPACE + +#endif /* _STLP_SPECIALIZED_DEQUE_H */ + +// Local Variables: +// mode:C++ +// End: diff --git a/WebKit/android/stlport/stl/pointers/_list.h b/WebKit/android/stlport/stl/pointers/_list.h new file mode 100644 index 0000000..441b11d --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_list.h @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2003 + * Francois Dumont + * + * 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_PTR_SPECIALIZED_LIST_H +#define _STLP_PTR_SPECIALIZED_LIST_H + +#ifndef _STLP_POINTERS_SPEC_TOOLS_H +# include <stl/pointers/_tools.h> +#endif + +_STLP_BEGIN_NAMESPACE + +#define LIST_IMPL _STLP_PTR_IMPL_NAME(list) + +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) + +_STLP_MOVE_TO_PRIV_NAMESPACE + +_STLP_EXPORT_TEMPLATE_CLASS _List_node<void*>; + +_STLP_MOVE_TO_STD_NAMESPACE + +_STLP_EXPORT_TEMPLATE_CLASS allocator<_STLP_PRIV _List_node<void*> >; + +_STLP_MOVE_TO_PRIV_NAMESPACE + +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_List_node_base, _List_node<void*>, allocator<_List_node<void*> > >; +_STLP_EXPORT_TEMPLATE_CLASS _List_base<void*, allocator<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS LIST_IMPL<void*, allocator<void*> >; + +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#if defined (_STLP_DEBUG) +# define list _STLP_NON_DBG_NAME(list) +_STLP_MOVE_TO_PRIV_NAMESPACE +#endif + +template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) > +class list +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (list) + : public __stlport_class<list<_Tp, _Alloc> > +#endif +{ + typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType; + typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV LIST_IMPL<_StorageType, _StorageTypeAlloc> _Base; + typedef typename _Base::iterator _BaseIte; + typedef typename _Base::const_iterator _BaseConstIte; + typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits; + typedef list<_Tp, _Alloc> _Self; + +public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + _STLP_FORCE_ALLOCATORS(value_type, _Alloc) + typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type; + typedef bidirectional_iterator_tag _Iterator_category; + + typedef _STLP_PRIV _List_iterator<value_type, _Nonconst_traits<value_type> > iterator; + typedef _STLP_PRIV _List_iterator<value_type, _Const_traits<value_type> > const_iterator; + + _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS; + + allocator_type get_allocator() const + { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); } + +# if !(defined(__MRC__)||(defined(__SC__) && !defined(__DMC__))) + explicit +# endif + list(const allocator_type& __a = allocator_type()) + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit list(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type), +#else + list(size_type __n, const value_type& __val, +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + const allocator_type& __a = allocator_type()) + : _M_impl(__n, cast_traits::to_storage_type_cref(__val), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit list(size_type __n) + : _M_impl(__n) {} +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) +# if !defined (_STLP_USE_ITERATOR_WRAPPER) + : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} +# else + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) { + insert(begin(), __first, __last); + } +# endif + +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + template <class _InputIterator> + list(_InputIterator __first, _InputIterator __last) +# if !defined (_STLP_USE_WRAPPER_ITERATOR) + : _M_impl(__first, __last) {} +# else + { insert(begin(), __first, __last); } +# endif +# endif + +#else /* _STLP_MEMBER_TEMPLATES */ + + list(const value_type *__first, const value_type *__last, + const allocator_type& __a = allocator_type()) + : _M_impl(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + list(const_iterator __first, const_iterator __last, + const allocator_type& __a = allocator_type()) + : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#endif /* _STLP_MEMBER_TEMPLATES */ + + list(const _Self& __x) : _M_impl(__x._M_impl) {} + + list(__move_source<_Self> src) + : _M_impl(__move_source<_Base>(src.get()._M_impl)) {} + + iterator begin() { return iterator(_M_impl.begin()._M_node); } + const_iterator begin() const { return const_iterator(_M_impl.begin()._M_node); } + + iterator end() { return iterator(_M_impl.end()._M_node); } + const_iterator end() const { return const_iterator(_M_impl.end()._M_node); } + + reverse_iterator rbegin() { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + + bool empty() const { return _M_impl.empty(); } + size_type size() const { return _M_impl.size(); } + size_type max_size() const { return _M_impl.max_size(); } + + reference front() { return *begin(); } + const_reference front() const { return *begin(); } + reference back() { return *(--end()); } + const_reference back() const { return *(--end()); } + + void swap(_Self &__x) { _M_impl.swap(__x._M_impl); } + void clear() { _M_impl.clear(); } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + iterator insert(iterator __pos, const_reference __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + iterator insert(iterator __pos, const_reference __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { return iterator(_M_impl.insert(_BaseIte(__pos._M_node), + cast_traits::to_storage_type_cref(__x))._M_node); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + const __true_type&) + { _M_impl.insert(_BaseIte(__pos._M_node), __n, __val); } + + template <class _InputIterator> + void _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.insert(_BaseIte(__pos._M_node), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); +# else + _M_impl.insert(_BaseIte(__pos._M_node), __first, __last); +# endif + } +#else /* _STLP_MEMBER_TEMPLATES */ + void insert(iterator __pos, const value_type *__first, const value_type *__last) + { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); } + void insert(iterator __pos, const_iterator __first, const_iterator __last) + { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + + void insert(iterator __pos, size_type __n, const value_type& __x) + { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); } + + void push_front(const value_type& __x) { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); } + void push_back(const value_type& __x) { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); } + +#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS) + iterator insert(iterator __pos) { return iterator(_M_impl.insert(__pos._M_node)._M_node); } + void push_front() { _M_impl.push_front();} + void push_back() { _M_impl.push_back();} +# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + + iterator erase(iterator __pos) + { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); } + iterator erase(iterator __first, iterator __last) + { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void resize(size_type __new_size) { _M_impl.resize(__new_size); } + void resize(size_type __new_size, const value_type& __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM*/ + {_M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));} + + void pop_front() { _M_impl.pop_front(); } + void pop_back() { _M_impl.pop_back(); } + + _Self& operator=(const _Self& __x) + { _M_impl = __x._M_impl; return *this; } + void assign(size_type __n, const value_type& __val) + { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&) + { _M_impl.assign(__n, __val); } + + template <class _InputIterator> + void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void assign(_InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_assign_dispatch(__first, __last, _Integral()); +# else + _M_impl.assign(__first, __last); +# endif + } +#else + void assign(const value_type *__first, const value_type *__last) { + _M_impl.assign(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + void assign(const_iterator __first, const_iterator __last) + { _M_impl.assign(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); } +#endif + + void splice(iterator __pos, _Self& __x) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); } + void splice(iterator __pos, _Self& __x, iterator __i) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); } + void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, + _BaseIte(__first._M_node), _BaseIte(__last._M_node)); } + + void remove(const_reference __val) + { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); } + void unique() { _M_impl.unique(); } + void merge(_Self& __x) { _M_impl.merge(__x._M_impl); } + void reverse() { _M_impl.reverse(); } + void sort() { _M_impl.sort(); } + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _Predicate> + void remove_if(_Predicate __pred) + { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); } + template <class _BinaryPredicate> + void unique(_BinaryPredicate __bin_pred) + { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__bin_pred)); } + + template <class _StrictWeakOrdering> + void merge(_Self &__x, _StrictWeakOrdering __comp) + { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); } + + template <class _StrictWeakOrdering> + void sort(_StrictWeakOrdering __comp) + { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + +private: + _Base _M_impl; +}; + +#if defined (list) +# undef list +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#undef LIST_IMPL + +_STLP_END_NAMESPACE + +#endif /* _STLP_PTR_SPECIALIZED_LIST_H */ + +// Local Variables: +// mode:C++ +// End: diff --git a/WebKit/android/stlport/stl/pointers/_set.h b/WebKit/android/stlport/stl/pointers/_set.h new file mode 100644 index 0000000..c66fd98 --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_set.h @@ -0,0 +1,536 @@ +/* + * Copyright (c) 2005 + * Francois Dumont + * + * 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_PTR_SPECIALIZED_SET_H +#define _STLP_PTR_SPECIALIZED_SET_H + +#ifndef _STLP_POINTERS_SPEC_TOOLS_H +# include <stl/pointers/_tools.h> +#endif + +_STLP_BEGIN_NAMESPACE + +//Specific iterator traits creation +_STLP_CREATE_ITERATOR_TRAITS(SetTraitsT, Const_traits) + +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC less<void*>; + +_STLP_MOVE_TO_PRIV_NAMESPACE + +typedef _Rb_tree_node<void*> _Node; +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Rb_tree_node_base, _Node, allocator<_Node> >; +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree_base<void*, allocator<void*> >; +# if defined (_STLP_DEBUG) +_STLP_EXPORT_TEMPLATE_CLASS _DbgCompare<void*, less<void*> >; +# define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree) +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, _DbgCompare<void*, less<void*> >, void*, _Identity<void*>, + _SetTraitsT<void*>, allocator<void*> >; +# undef _Rb_tree +# endif +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, less<void*>, void*, _Identity<void*>, + _SetTraitsT<void*>, allocator<void*> >; +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>), + _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) > +class set +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) + : public __stlport_class<set<_Key, _Compare, _Alloc> > +#endif +{ + typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes; + typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType; + typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType; + typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits; + + typedef set<_Key, _Compare, _Alloc> _Self; +public: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + +protected: + //Specific iterator traits creation + typedef _STLP_PRIV _SetTraitsT<value_type> _SetTraits; + typedef _STLP_PRIV _Rb_tree<key_type, key_compare, + value_type, _STLP_PRIV _Identity<value_type>, + _SetTraits, _Alloc> _Priv_Rep_type; + + typedef _STLP_PRIV _SetTraitsT<_KeyStorageType> _SetStorageTraits; + +public: + //dums: need the following public for the __move_traits framework + typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType, + _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>, + _SetStorageTraits, _StorageTypeAlloc> _Rep_type; + +private: + typedef typename _Rep_type::iterator base_iterator; + typedef typename _Rep_type::const_iterator const_base_iterator; + +public: + typedef typename _Priv_Rep_type::pointer pointer; + typedef typename _Priv_Rep_type::const_pointer const_pointer; + typedef typename _Priv_Rep_type::reference reference; + typedef typename _Priv_Rep_type::const_reference const_reference; + typedef typename _Priv_Rep_type::iterator iterator; + typedef typename _Priv_Rep_type::const_iterator const_iterator; + typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator; + typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator; + typedef typename _Priv_Rep_type::size_type size_type; + typedef typename _Priv_Rep_type::difference_type difference_type; + typedef typename _Priv_Rep_type::allocator_type allocator_type; + +private: + _Rep_type _M_t; // red-black tree representing set + _STLP_KEY_TYPE_FOR_CONT_EXT(key_type) + +#if defined (_STLP_DEBUG) + static iterator _S_to_value_ite(const_base_iterator __ite) + { return iterator(__ite._Owner(), __ite._M_iterator._M_node); } + static base_iterator _S_to_storage_ite(const_iterator __ite) + { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); } +#else + static iterator _S_to_value_ite(const_base_iterator __ite) + { return iterator(__ite._M_node); } + static base_iterator _S_to_storage_ite(const_iterator __ite) + { return base_iterator(__ite._M_node); } +#endif + +public: + set() : _M_t(_CompareStorageType(), _StorageTypeAlloc()) {} + explicit set(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {} + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + set(_InputIterator __first, _InputIterator __last) + : _M_t(_Compare(), _StorageTypeAlloc()) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_unique(__first, __last); +# endif + } + +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + template <class _InputIterator> + set(_InputIterator __first, _InputIterator __last, const _Compare& __comp) + : _M_t(__comp, _StorageTypeAlloc()) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_unique(__first, __last); +# endif + } +# endif + template <class _InputIterator> + set(_InputIterator __first, _InputIterator __last, const _Compare& __comp, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_unique(__first, __last); +# endif + } +#else + set(const value_type* __first, const value_type* __last) + : _M_t(_Compare(), _StorageTypeAlloc()) { + _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + + set(const value_type* __first, const value_type* __last, + const _Compare& __comp, const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) { + _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + + set(const_iterator __first, const_iterator __last) + : _M_t(_Compare(), _StorageTypeAlloc()) + { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } + + set(const_iterator __first, const_iterator __last, + const _Compare& __comp, const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) + { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + + set(const _Self& __x) : _M_t(__x._M_t) {} + + set(__move_source<_Self> src) + : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {} + + _Self& operator=(const _Self& __x) { + _M_t = __x._M_t; + return *this; + } + + // accessors: + key_compare key_comp() const { return _M_t.key_comp(); } + value_compare value_comp() const { return _M_t.key_comp(); } + allocator_type get_allocator() const + { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); } + + iterator begin() { return _S_to_value_ite(_M_t.begin()); } + iterator end() { return _S_to_value_ite(_M_t.end()); } + const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); } + const_iterator end() const { return _S_to_value_ite(_M_t.end()); } + reverse_iterator rbegin() { return reverse_iterator(end()); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + bool empty() const { return _M_t.empty(); } + size_type size() const { return _M_t.size(); } + size_type max_size() const { return _M_t.max_size(); } + void swap(_Self& __x) { _M_t.swap(__x._M_t); } + + // insert/erase + pair<iterator,bool> insert(const value_type& __x) { + pair<base_iterator, bool> ret = _M_t.insert_unique(cast_traits::to_storage_type_cref(__x)); + return pair<iterator, bool>(_S_to_value_ite(ret.first), ret.second); + } + iterator insert(iterator __pos, const value_type& __x) + { return _S_to_value_ite(_M_t.insert_unique(_S_to_storage_ite(__pos), cast_traits::to_storage_type_cref(__x))); } + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + void insert(_InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_unique(__first, __last); +# endif + } +#else + void insert(const_iterator __first, const_iterator __last) + { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } + void insert(const value_type* __first, const value_type* __last) { + _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } +#endif + void erase(iterator __pos) + { _M_t.erase(_S_to_storage_ite(__pos)); } + size_type erase(const key_type& __x) + { return _M_t.erase_unique(cast_traits::to_storage_type_cref(__x)); } + void erase(iterator __first, iterator __last) + { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } + void clear() { _M_t.clear(); } + + // set operations: + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator find(const _KT& __x) const + { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + iterator find(const _KT& __x) + { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + size_type count(const _KT& __x) const + { return _M_t.find(cast_traits::to_storage_type_crefT(__x)) == _M_t.end() ? 0 : 1; } + _STLP_TEMPLATE_FOR_CONT_EXT + iterator lower_bound(const _KT& __x) + { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator lower_bound(const _KT& __x) const + { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + iterator upper_bound(const _KT& __x) + { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator upper_bound(const _KT& __x) const + { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + pair<iterator, iterator> equal_range(const _KT& __x) { + pair<base_iterator, base_iterator> __ret; + __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x)); + return pair<iterator, iterator>(_S_to_value_ite(__ret.first), + _S_to_value_ite(__ret.second)); + } + _STLP_TEMPLATE_FOR_CONT_EXT + pair<const_iterator, const_iterator> equal_range(const _KT& __x) const { + pair<const_base_iterator, const_base_iterator> __ret; + __ret = _M_t.equal_range_unique(cast_traits::to_storage_type_crefT(__x)); + return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first), + _S_to_value_ite(__ret.second)); + } +}; + +//Specific iterator traits creation +_STLP_CREATE_ITERATOR_TRAITS(MultisetTraitsT, Const_traits) + +template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>), + _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) > +class multiset +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) + : public __stlport_class<multiset<_Key, _Compare, _Alloc> > +#endif +{ + typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes; + typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType; + typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType; + typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits; + + typedef multiset<_Key, _Compare, _Alloc> _Self; +public: + // typedefs: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + +protected: + //Specific iterator traits creation + typedef _STLP_PRIV _MultisetTraitsT<value_type> _MultisetTraits; + typedef _STLP_PRIV _Rb_tree<key_type, key_compare, + value_type, _STLP_PRIV _Identity<value_type>, + _MultisetTraits, _Alloc> _Priv_Rep_type; + + typedef _STLP_PRIV _MultisetTraitsT<_KeyStorageType> _MultisetStorageTraits; +public: + //dums: need the following public for the __move_traits framework + typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType, + _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>, + _MultisetStorageTraits, _StorageTypeAlloc> _Rep_type; + +private: + typedef typename _Rep_type::iterator base_iterator; + typedef typename _Rep_type::const_iterator const_base_iterator; + +public: + typedef typename _Priv_Rep_type::pointer pointer; + typedef typename _Priv_Rep_type::const_pointer const_pointer; + typedef typename _Priv_Rep_type::reference reference; + typedef typename _Priv_Rep_type::const_reference const_reference; + typedef typename _Priv_Rep_type::iterator iterator; + typedef typename _Priv_Rep_type::const_iterator const_iterator; + typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator; + typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator; + typedef typename _Priv_Rep_type::size_type size_type; + typedef typename _Priv_Rep_type::difference_type difference_type; + typedef typename _Priv_Rep_type::allocator_type allocator_type; + +private: + _Rep_type _M_t; // red-black tree representing multiset + _STLP_KEY_TYPE_FOR_CONT_EXT(key_type) + +#if defined (_STLP_DEBUG) + static iterator _S_to_value_ite(const_base_iterator __ite) + { return iterator(__ite._Owner(), __ite._M_iterator._M_node); } + static base_iterator _S_to_storage_ite(const_iterator __ite) + { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); } +#else + static iterator _S_to_value_ite(const_base_iterator __ite) + { return iterator(__ite._M_node); } + static base_iterator _S_to_storage_ite(const_iterator __ite) + { return base_iterator(__ite._M_node); } +#endif + +public: + multiset() : _M_t(_Compare(), _StorageTypeAlloc()) {} + explicit multiset(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {} + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + multiset(_InputIterator __first, _InputIterator __last) + : _M_t(_Compare(), _StorageTypeAlloc()) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_equal(__first, __last); +# endif + } + +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + template <class _InputIterator> + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp) + : _M_t(__comp, _StorageTypeAlloc()) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_equal(__first, __last); +# endif + } +# endif + template <class _InputIterator> + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_equal(__first, __last); +# endif + } + +#else + multiset(const value_type* __first, const value_type* __last) + : _M_t(_Compare(), _StorageTypeAlloc()) { + _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + + multiset(const value_type* __first, const value_type* __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) { + _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + + multiset(const_iterator __first, const_iterator __last) + : _M_t(_Compare(), _StorageTypeAlloc()) + { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } + + multiset(const_iterator __first, const_iterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) + { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + + multiset(const _Self& __x) + : _M_t(__x._M_t) {} + + _Self& operator=(const _Self& __x) { + _M_t = __x._M_t; + return *this; + } + + multiset(__move_source<_Self> src) + : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {} + + // accessors: + key_compare key_comp() const { return _M_t.key_comp(); } + value_compare value_comp() const { return _M_t.key_comp(); } + allocator_type get_allocator() const + { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); } + + iterator begin() { return _S_to_value_ite(_M_t.begin()); } + iterator end() { return _S_to_value_ite(_M_t.end()); } + const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); } + const_iterator end() const { return _S_to_value_ite(_M_t.end()); } + reverse_iterator rbegin() { return reverse_iterator(end()); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + bool empty() const { return _M_t.empty(); } + size_type size() const { return _M_t.size(); } + size_type max_size() const { return _M_t.max_size(); } + void swap(_Self& __x) { _M_t.swap(__x._M_t); } + + // insert/erase + iterator insert(const value_type& __x) + { return _S_to_value_ite(_M_t.insert_equal(cast_traits::to_storage_type_cref(__x))); } + iterator insert(iterator __pos, const value_type& __x) { + return _S_to_value_ite(_M_t.insert_equal(_S_to_storage_ite(__pos), + cast_traits::to_storage_type_cref(__x))); + } + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + void insert(_InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last)); +# else + _M_t.insert_equal(__first, __last); +# endif + } +#else + void insert(const value_type* __first, const value_type* __last) { + _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + void insert(const_iterator __first, const_iterator __last) + { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + + void erase(iterator __pos) + { _M_t.erase(_S_to_storage_ite(__pos)); } + size_type erase(const key_type& __x) + { return _M_t.erase(cast_traits::to_storage_type_cref(__x)); } + void erase(iterator __first, iterator __last) + { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); } + void clear() { _M_t.clear(); } + + // multiset operations: + + _STLP_TEMPLATE_FOR_CONT_EXT + iterator find(const _KT& __x) + { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator find(const _KT& __x) const + { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + size_type count(const _KT& __x) const + { return _M_t.count(cast_traits::to_storage_type_crefT(__x)); } + _STLP_TEMPLATE_FOR_CONT_EXT + iterator lower_bound(const _KT& __x) + { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator lower_bound(const _KT& __x) const + { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + iterator upper_bound(const _KT& __x) + { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + const_iterator upper_bound(const _KT& __x) const + { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); } + _STLP_TEMPLATE_FOR_CONT_EXT + pair<iterator, iterator> equal_range(const _KT& __x) { + pair<base_iterator, base_iterator> __ret; + __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x)); + return pair<iterator, iterator>(_S_to_value_ite(__ret.first), + _S_to_value_ite(__ret.second)); + } + _STLP_TEMPLATE_FOR_CONT_EXT + pair<const_iterator, const_iterator> equal_range(const _KT& __x) const { + pair<const_base_iterator, const_base_iterator> __ret; + __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x)); + return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first), + _S_to_value_ite(__ret.second)); + } +}; + +_STLP_END_NAMESPACE + +#endif /* _STLP_PTR_SPECIALIZED_SET_H */ + +// Local Variables: +// mode:C++ +// End: diff --git a/WebKit/android/stlport/stl/pointers/_slist.h b/WebKit/android/stlport/stl/pointers/_slist.h new file mode 100644 index 0000000..93ff211 --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_slist.h @@ -0,0 +1,413 @@ +/* + * Copyright (c) 2003 + * Francois Dumont + * + * 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_SPECIALIZED_SLIST_H +#define _STLP_SPECIALIZED_SLIST_H + +#ifndef _STLP_POINTERS_SPEC_TOOLS_H +# include <stl/pointers/_tools.h> +#endif + +_STLP_BEGIN_NAMESPACE + +#define SLIST_IMPL _STLP_PTR_IMPL_NAME(slist) + +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +_STLP_MOVE_TO_PRIV_NAMESPACE + +_STLP_EXPORT_TEMPLATE_CLASS _Slist_node<void*>; +typedef _Slist_node<void*> _VoidPtrSNode; +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base, _VoidPtrSNode, allocator<_VoidPtrSNode> >; +_STLP_EXPORT_TEMPLATE_CLASS _Slist_base<void*, allocator<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS SLIST_IMPL<void*, allocator<void*> >; + +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#if defined (_STLP_DEBUG) +# define slist _STLP_NON_DBG_NAME(slist) +_STLP_MOVE_TO_PRIV_NAMESPACE +#endif + +template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) > +class slist +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist) + : public __stlport_class<slist<_Tp, _Alloc> > +#endif +{ + typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType; + typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV SLIST_IMPL<_StorageType, _StorageTypeAlloc> _Base; + typedef typename _Base::iterator _BaseIte; + typedef typename _Base::const_iterator _BaseConstIte; + typedef slist<_Tp, _Alloc> _Self; + typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits; + typedef _STLP_PRIV _Slist_node_base _Node_base; + +public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef forward_iterator_tag _Iterator_category; + + typedef _STLP_PRIV _Slist_iterator<value_type, _Nonconst_traits<value_type> > iterator; + typedef _STLP_PRIV _Slist_iterator<value_type, _Const_traits<value_type> > const_iterator; + + _STLP_FORCE_ALLOCATORS(value_type, _Alloc) + typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type; + +public: + allocator_type get_allocator() const + { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); } + + explicit slist(const allocator_type& __a = allocator_type()) + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type), +#else + slist(size_type __n, const value_type& __x, +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + const allocator_type& __a = allocator_type()) + : _M_impl(__n, cast_traits::to_storage_type_cref(__x), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit slist(size_type __n) : _M_impl(__n) {} +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + +#if defined (_STLP_MEMBER_TEMPLATES) + // We don't need any dispatching tricks here, because _M_insert_after_range + // already does them. + template <class _InputIterator> + slist(_InputIterator __first, _InputIterator __last, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) +# if !defined (_STLP_USE_ITERATOR_WRAPPER) + : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} +# else + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) { + insert_after(before_begin(), __first, __last); + } +# endif +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + // VC++ needs this crazyness + template <class _InputIterator> + slist(_InputIterator __first, _InputIterator __last) +# if !defined (_STLP_USE_WRAPPER_ITERATOR) + : _M_impl(__first, __last) {} +# else + { insert_after(before_begin(), __first, __last); } +# endif +# endif +#else /* _STLP_MEMBER_TEMPLATES */ + slist(const_iterator __first, const_iterator __last, + const allocator_type& __a = allocator_type() ) + : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + slist(const value_type* __first, const value_type* __last, + const allocator_type& __a = allocator_type()) + : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} +#endif /* _STLP_MEMBER_TEMPLATES */ + + slist(const _Self& __x) : _M_impl(__x._M_impl) {} + slist(__move_source<_Self> src) + : _M_impl(__move_source<_Base>(src.get()._M_impl)) {} + + _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; } + + void assign(size_type __n, const value_type& __val) + { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_assign_dispatch(_Integer __n, _Integer __val, + const __true_type&) + { _M_impl.assign(__n, __val); } + + template <class _InputIterator> + void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void assign(_InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_assign_dispatch(__first, __last, _Integral()); +# else + _M_impl.assign(__first, __last); +# endif + } +#else + void assign(const value_type *__first, const value_type *__last) { + _M_impl.assign(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } + void assign(const_iterator __first, const_iterator __last) { + _M_impl.assign(_BaseConstIte(__first._M_node), + _BaseConstIte(__last._M_node)); + } +#endif /* _STLP_MEMBER_TEMPLATES */ + + iterator before_begin() { return iterator(_M_impl.before_begin()._M_node); } + const_iterator before_begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.before_begin()._M_node)); } + + iterator begin() { return iterator(_M_impl.begin()._M_node); } + const_iterator begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.begin()._M_node));} + + iterator end() { return iterator(_M_impl.end()._M_node); } + const_iterator end() const { return iterator(_M_impl.end()._M_node); } + + size_type size() const { return _M_impl.size(); } + size_type max_size() const { return _M_impl.max_size(); } + bool empty() const { return _M_impl.empty(); } + + void swap(_Self& __x) { _M_impl.swap(__x._M_impl); } + +public: + reference front() { return *begin(); } + const_reference front() const { return *begin(); } +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + void push_front(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void push_front(const value_type& __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); } + +# if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + void push_front() { _M_impl.push_front();} +# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + + void pop_front() { _M_impl.pop_front(); } + + iterator previous(const_iterator __pos) + { return iterator(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node); } + const_iterator previous(const_iterator __pos) const + { return const_iterator(const_cast<_Node_base*>(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node)); } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + iterator insert_after(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + iterator insert_after(iterator __pos, const value_type& __x) +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node), + cast_traits::to_storage_type_cref(__x))._M_node); } + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + iterator insert_after(iterator __pos) + { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node))._M_node);} +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + void insert_after(iterator __pos, size_type __n, const value_type& __x) + { _M_impl.insert_after(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_insert_after_dispatch(iterator __pos, _Integer __n, _Integer __val, + const __true_type&) { + _M_impl.insert_after(_BaseIte(__pos._M_node), __n, __val); + } + + template <class _InputIterator> + void _M_insert_after_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.insert_after(_BaseIte(__pos._M_node), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void insert_after(iterator __pos, _InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_insert_after_dispatch(__pos, __first, __last, _Integral()); +# else + _M_impl.insert_after(_BaseIte(__pos._M_node), __first, __last); +# endif + } + +#else /* _STLP_MEMBER_TEMPLATES */ + void insert_after(iterator __pos, + const_iterator __first, const_iterator __last) + { _M_impl.insert_after(_BaseIte(__pos._M_node), + _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); } + void insert_after(iterator __pos, + const value_type* __first, const value_type* __last) { + _M_impl.insert_after(_BaseIte(__pos._M_node), + cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } +#endif /* _STLP_MEMBER_TEMPLATES */ + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + iterator insert(iterator __pos, const value_type& __x) +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + { return iterator(_M_impl.insert(_BaseIte(__pos._M_node), + cast_traits::to_storage_type_cref(__x))._M_node); } + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + iterator insert(iterator __pos) + { return iterator(_M_impl.insert(_BaseIte(__pos._M_node))._M_node); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + void insert(iterator __pos, size_type __n, const value_type& __x) + { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); } + +#if defined (_STLP_MEMBER_TEMPLATES) +# if defined (_STLP_USE_ITERATOR_WRAPPER) +private: + template <class _Integer> + void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + const __true_type&) { + _M_impl.insert(_BaseIte(__pos._M_node), __n, __val); + } + + template <class _InputIterator> + void _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + const __false_type&) { + _M_impl.insert(_BaseIte(__pos._M_node), typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first), + typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last)); + } + +public: +# endif + + template <class _InputIterator> + void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { +# if defined (_STLP_USE_ITERATOR_WRAPPER) + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); +# else + _M_impl.insert(_BaseIte(__pos._M_node), __first, __last); +# endif + } + +#else /* _STLP_MEMBER_TEMPLATES */ + void insert(iterator __pos, const_iterator __first, const_iterator __last) + { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); } + void insert(iterator __pos, const value_type* __first, const value_type* __last) + { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + + iterator erase_after(iterator __pos) + { return iterator(_M_impl.erase_after(_BaseIte(__pos._M_node))._M_node); } + iterator erase_after(iterator __before_first, iterator __last) + { return iterator(_M_impl.erase_after(_BaseIte(__before_first._M_node), + _BaseIte(__last._M_node))._M_node); } + + iterator erase(iterator __pos) + { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); } + iterator erase(iterator __first, iterator __last) + { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void resize(size_type __new_size, const value_type& __x) +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));} + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size) { _M_impl.resize(__new_size); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + void clear() { _M_impl.clear(); } + + void splice_after(iterator __pos, _Self& __x, + iterator __before_first, iterator __before_last) + { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, + _BaseIte(__before_first._M_node), _BaseIte(__before_last._M_node)); } + void splice_after(iterator __pos, _Self& __x, iterator __prev) + { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__prev._M_node)); } + void splice_after(iterator __pos, _Self& __x) + { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl); } + void splice(iterator __pos, _Self& __x) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); } + void splice(iterator __pos, _Self& __x, iterator __i) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); } + void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) + { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, + _BaseIte(__first._M_node), _BaseIte(__last._M_node)); } + + void reverse() { _M_impl.reverse(); } + + void remove(const value_type& __val) { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); } + void unique() { _M_impl.unique(); } + void merge(_Self& __x) { _M_impl.merge(__x._M_impl); } + void sort() {_M_impl.sort(); } + +#ifdef _STLP_MEMBER_TEMPLATES + template <class _Predicate> + void remove_if(_Predicate __pred) + { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); } + + template <class _BinaryPredicate> + void unique(_BinaryPredicate __pred) + { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__pred)); } + + template <class _StrictWeakOrdering> + void merge(_Self& __x, _StrictWeakOrdering __comp) + { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); } + + template <class _StrictWeakOrdering> + void sort(_StrictWeakOrdering __comp) + { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); } +#endif /* _STLP_MEMBER_TEMPLATES */ + +private: + _Base _M_impl; +}; + +#if defined (slist) +# undef slist +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#undef SLIST_IMPL + +_STLP_END_NAMESPACE + +#endif /* _STLP_SPECIALIZED_SLIST_H */ + +// Local Variables: +// mode:C++ +// End: diff --git a/WebKit/android/stlport/stl/pointers/_tools.h b/WebKit/android/stlport/stl/pointers/_tools.h new file mode 100644 index 0000000..e02fc42 --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_tools.h @@ -0,0 +1,400 @@ +/* + * Copyright (c) 2003 + * Francois Dumont + * + * 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_POINTERS_SPEC_TOOLS_H +#define _STLP_POINTERS_SPEC_TOOLS_H + +#ifndef _STLP_TYPE_TRAITS_H +# include <stl/type_traits.h> +#endif + +_STLP_BEGIN_NAMESPACE + +//Some usefull declarations: +template <class _Tp> struct less; + +_STLP_MOVE_TO_PRIV_NAMESPACE + +template <class _StorageT, class _ValueT, class _BinaryPredicate> +struct _BinaryPredWrapper; + +/* + * Since the compiler only allows at most one non-trivial + * implicit conversion we can make use of a shim class to + * be sure that functions below doesn't accept classes with + * implicit pointer conversion operators + */ +struct _ConstVolatileVoidPointerShim +{ _ConstVolatileVoidPointerShim(const volatile void*); }; + +//The dispatch functions: +struct _VoidPointerShim +{ _VoidPointerShim(void*); }; +struct _ConstVoidPointerShim +{ _ConstVoidPointerShim(const void*); }; +struct _VolatileVoidPointerShim +{ _VolatileVoidPointerShim(volatile void*); }; + +template <class _Tp> +char _UseVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); +char _UseVoidPtrStorageType(const __true_type& /*POD*/, ...); +char* _UseVoidPtrStorageType(const __true_type& /*POD*/, _VoidPointerShim); + +template <class _Tp> +char _UseConstVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); +char _UseConstVoidPtrStorageType(const __true_type& /*POD*/, ...); +char* _UseConstVoidPtrStorageType(const __true_type& /*POD*/, _ConstVoidPointerShim); + +template <class _Tp> +char _UseVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); +char _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...); +char* _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, _VolatileVoidPointerShim); + +template <class _Tp> +char _UseConstVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); +char _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...); +char* _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, _ConstVolatileVoidPointerShim); + +template <class _Tp> +struct _StorageType { + typedef typename __type_traits<_Tp>::is_POD_type _PODType; + static _Tp __null_rep(); + + enum { use_void_ptr = (sizeof(_UseVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; + enum { use_const_void_ptr = (sizeof(_UseConstVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; + enum { use_volatile_void_ptr = (sizeof(_UseVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; + enum { use_const_volatile_void_ptr = (sizeof(_UseConstVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; + + typedef typename __select<!use_const_volatile_void_ptr, + _Tp, + typename __select<use_void_ptr, + void*, + typename __select<use_const_void_ptr, + const void*, + typename __select<use_volatile_void_ptr, + volatile void*, + const volatile void*>::_Ret >::_Ret >::_Ret >::_Ret _QualifiedType; + +#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) + /* If the compiler do not support the iterator_traits structure we cannot wrap + * iterators pass to container template methods. The iterator dereferenced value + * has to be storable without any cast in the chosen storage type. To guaranty + * that the void pointer has to be correctly qualified. + */ + typedef _QualifiedType _Type; +#else + /* With iterator_traits we can wrap passed iterators and make the necessary casts. + * We can always use a simple void* storage type: + */ + typedef typename __select<use_const_volatile_void_ptr, + void*, + _Tp>::_Ret _Type; +#endif +}; + +template <class _Tp, class _Compare> +struct _AssocStorageTypes { + typedef _StorageType<_Tp> _StorageTypeInfo; + typedef typename _StorageTypeInfo::_Type _SType; + + //We need to also check that the comparison functor used to instanciate the assoc container + //is the default Standard less implementation: + typedef typename _IsSTLportClass<_Compare>::_Ret _STLportLess; + enum { is_default_less = __type2bool<_STLportLess>::_Ret }; + + typedef typename __select<is_default_less, _SType, _Tp>::_Ret _KeyStorageType; + enum { ptr_type = _StorageTypeInfo::use_const_volatile_void_ptr }; + typedef typename __select<is_default_less && ptr_type, + _BinaryPredWrapper<_KeyStorageType, _Tp, _Compare>, + _Compare>::_Ret _CompareStorageType; +}; + + +#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) +/* + * Base struct to deal with qualifiers + */ +template <class _StorageT, class _QualifiedStorageT> +struct _VoidCastTraitsAux { + typedef _QualifiedStorageT void_cv_type; + typedef _StorageT void_type; + + static void_type * uncv_ptr(void_cv_type *__ptr) + { return __ptr; } + static void_type const* uncv_cptr(void_cv_type const*__ptr) + { return __ptr; } + static void_type ** uncv_pptr(void_cv_type **__ptr) + { return __ptr; } + static void_type & uncv_ref(void_cv_type & __ref) + { return __ref; } + static void_type const& uncv_cref(void_cv_type const& __ref) + { return __ref; } + static void_cv_type* cv_ptr(void_type *__ptr) + { return __ptr; } + static void_cv_type const* cv_cptr(void_type const*__ptr) + { return __ptr; } + static void_cv_type ** cv_pptr(void_type **__ptr) + { return __ptr; } + static void_cv_type & cv_ref(void_type & __ref) + { return __ref; } + static void_cv_type const& cv_cref(void_type const& __ref) + { return __ref; } +}; + +template <class _VoidCVType> +struct _VoidCastTraitsAuxBase { + typedef _VoidCVType* void_cv_type; + typedef void* void_type; + + static void_type* uncv_ptr(void_cv_type *__ptr) + { return __CONST_CAST(void_type*, __ptr); } + static void_type const* uncv_cptr(void_cv_type const*__ptr) + { return __CONST_CAST(void_type const*, __ptr); } + static void_type** uncv_pptr(void_cv_type **__ptr) + { return __CONST_CAST(void_type**, __ptr); } + static void_type& uncv_ref(void_cv_type &__ref) + { return __CONST_CAST(void_type&, __ref); } + static void_type const& uncv_cref(void_cv_type const& __ptr) + { return __CONST_CAST(void_type const&, __ptr); } + // The reverse versions + static void_cv_type * cv_ptr(void_type *__ptr) + { return __CONST_CAST(void_cv_type *, __ptr); } + static void_cv_type const* cv_cptr(void_type const*__ptr) + { return __CONST_CAST(void_cv_type const*, __ptr); } + static void_cv_type ** cv_pptr(void_type **__ptr) + { return __CONST_CAST(void_cv_type**, __ptr); } + static void_cv_type & cv_ref(void_type &__ref) + { return __CONST_CAST(void_cv_type &, __ref); } + static void_cv_type const& cv_cref(void_type const& __ref) + { return __CONST_CAST(void_cv_type const&, __ref); } +}; + +_STLP_TEMPLATE_NULL +struct _VoidCastTraitsAux<void*, const void*> : _VoidCastTraitsAuxBase<void const> +{}; +_STLP_TEMPLATE_NULL +struct _VoidCastTraitsAux<void*, volatile void*> : _VoidCastTraitsAuxBase<void volatile> +{}; +_STLP_TEMPLATE_NULL +struct _VoidCastTraitsAux<void*, const volatile void*> : _VoidCastTraitsAuxBase<void const volatile> +{}; + +template <class _StorageT, class _ValueT> +struct _CastTraits { + typedef _ValueT value_type; + typedef typename _StorageType<_ValueT>::_QualifiedType _QualifiedStorageT; + typedef _VoidCastTraitsAux<_StorageT, _QualifiedStorageT> cv_traits; + typedef typename cv_traits::void_type void_type; + typedef typename cv_traits::void_cv_type void_cv_type; + + static value_type * to_value_type_ptr(void_type *__ptr) + { return __REINTERPRET_CAST(value_type *, cv_traits::cv_ptr(__ptr)); } + static value_type const* to_value_type_cptr(void_type const*__ptr) + { return __REINTERPRET_CAST(value_type const*, cv_traits::cv_cptr(__ptr)); } + static value_type ** to_value_type_pptr(void_type **__ptr) + { return __REINTERPRET_CAST(value_type **, cv_traits::cv_pptr(__ptr)); } + static value_type & to_value_type_ref(void_type &__ref) + { return __REINTERPRET_CAST(value_type &, cv_traits::cv_ref(__ref)); } + static value_type const& to_value_type_cref(void_type const& __ptr) + { return __REINTERPRET_CAST(value_type const&, cv_traits::cv_cref(__ptr)); } + // Reverse versions + static void_type * to_storage_type_ptr(value_type *__ptr) + { return cv_traits::uncv_ptr(__REINTERPRET_CAST(void_cv_type *, __ptr)); } + static void_type const* to_storage_type_cptr(value_type const*__ptr) + { return cv_traits::uncv_cptr(__REINTERPRET_CAST(void_cv_type const*, __ptr)); } + static void_type ** to_storage_type_pptr(value_type **__ptr) + { return cv_traits::uncv_pptr(__REINTERPRET_CAST(void_cv_type **, __ptr)); } + static void_type const& to_storage_type_cref(value_type const& __ref) + { return cv_traits::uncv_cref(__REINTERPRET_CAST(void_cv_type const&, __ref)); } + + //Method used to treat set container template method extension + static void_type const& to_storage_type_crefT(value_type const& __ref) + { return to_storage_type_cref(__ref); } +}; + +template <class _Tp> +struct _CastTraits<_Tp, _Tp> { + typedef _Tp storage_type; + typedef _Tp value_type; + + static value_type * to_value_type_ptr(storage_type *__ptr) + { return __ptr; } + static value_type const* to_value_type_cptr(storage_type const*__ptr) + { return __ptr; } + static value_type ** to_value_type_pptr(storage_type **__ptr) + { return __ptr; } + static value_type & to_value_type_ref(storage_type &__ref) + { return __ref; } + static value_type const& to_value_type_cref(storage_type const&__ref) + { return __ref; } + // Reverse versions + static storage_type * to_storage_type_ptr(value_type *__ptr) + { return __ptr; } + static storage_type const* to_storage_type_cptr(value_type const*__ptr) + { return __ptr; } + static storage_type ** to_storage_type_pptr(value_type **__ptr) + { return __ptr; } + static storage_type const& to_storage_type_cref(value_type const& __ref) + { return __ref; } + + //Method used to treat set container template method extension + template <class _Tp1> + static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref) + { return __ref; } +}; + +#define _STLP_USE_ITERATOR_WRAPPER + +template <class _StorageT, class _ValueT, class _Iterator> +struct _IteWrapper { + typedef _CastTraits<_StorageT, _ValueT> cast_traits; + typedef iterator_traits<_Iterator> _IteTraits; + + typedef typename _IteTraits::iterator_category iterator_category; + typedef _StorageT value_type; + typedef typename _IteTraits::difference_type difference_type; + typedef value_type* pointer; + typedef value_type const& const_reference; + //This wrapper won't be used for input so to avoid surprise + //the reference type will be a const reference: + typedef const_reference reference; + + typedef _IteWrapper<_StorageT, _ValueT, _Iterator> _Self; + typedef _Self _Ite; + + _IteWrapper(_Iterator &__ite) : _M_ite(__ite) {} + + const_reference operator*() const { return cast_traits::to_storage_type_cref(*_M_ite); } + + _Self& operator= (_Self const& __rhs) { + _M_ite = __rhs._M_ite; + return *this; + } + + _Self& operator++() { + ++_M_ite; + return *this; + } + + _Self& operator--() { + --_M_ite; + return *this; + } + + _Self& operator += (difference_type __offset) { + _M_ite += __offset; + return *this; + } + difference_type operator -(_Self const& __other) const + { return _M_ite - __other._M_ite; } + + bool operator == (_Self const& __other) const + { return _M_ite == __other._M_ite; } + + bool operator != (_Self const& __other) const + { return _M_ite != __other._M_ite; } + + bool operator < (_Self const& __rhs) const + { return _M_ite < __rhs._M_ite; } + +private: + _Iterator _M_ite; +}; + +template <class _Tp, class _Iterator> +struct _IteWrapper<_Tp, _Tp, _Iterator> +{ typedef _Iterator _Ite; }; + +#else + +/* + * In this config the storage type is qualified in respect of the + * value_type qualification. Simple reinterpret_cast is enough. + */ +template <class _StorageT, class _ValueT> +struct _CastTraits { + typedef _StorageT storage_type; + typedef _ValueT value_type; + + static value_type * to_value_type_ptr(storage_type *__ptr) + { return __REINTERPRET_CAST(value_type*, __ptr); } + static value_type const* to_value_type_cptr(storage_type const*__ptr) + { return __REINTERPRET_CAST(value_type const*, __ptr); } + static value_type ** to_value_type_pptr(storage_type **__ptr) + { return __REINTERPRET_CAST(value_type **, __ptr); } + static value_type & to_value_type_ref(storage_type &__ref) + { return __REINTERPRET_CAST(value_type&, __ref); } + static value_type const& to_value_type_cref(storage_type const&__ref) + { return __REINTERPRET_CAST(value_type const&, __ref); } + // Reverse versions + static storage_type * to_storage_type_ptr(value_type *__ptr) + { return __REINTERPRET_CAST(storage_type*, __ptr); } + static storage_type const* to_storage_type_cptr(value_type const*__ptr) + { return __REINTERPRET_CAST(storage_type const*, __ptr); } + static storage_type ** to_storage_type_pptr(value_type **__ptr) + { return __REINTERPRET_CAST(storage_type **, __ptr); } + static storage_type const& to_storage_type_cref(value_type const&__ref) + { return __REINTERPRET_CAST(storage_type const&, __ref); } + template <class _Tp1> + static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref) + { return __ref; } +}; + +#endif + +//Wrapper functors: +template <class _StorageT, class _ValueT, class _UnaryPredicate> +struct _UnaryPredWrapper { + typedef _CastTraits<_StorageT, _ValueT> cast_traits; + + _UnaryPredWrapper (_UnaryPredicate const& __pred) : _M_pred(__pred) {} + + bool operator () (_StorageT const& __ref) const + { return _M_pred(cast_traits::to_value_type_cref(__ref)); } + +private: + _UnaryPredicate _M_pred; +}; + +template <class _StorageT, class _ValueT, class _BinaryPredicate> +struct _BinaryPredWrapper { + typedef _CastTraits<_StorageT, _ValueT> cast_traits; + + _BinaryPredWrapper () {} + _BinaryPredWrapper (_BinaryPredicate const& __pred) : _M_pred(__pred) {} + + _BinaryPredicate get_pred() const { return _M_pred; } + + bool operator () (_StorageT const& __fst, _StorageT const& __snd) const + { return _M_pred(cast_traits::to_value_type_cref(__fst), cast_traits::to_value_type_cref(__snd)); } + + //Cast operator used to transparently access underlying predicate + //in set::key_comp() method + operator _BinaryPredicate() const + { return _M_pred; } + +private: + _BinaryPredicate _M_pred; +}; + +_STLP_MOVE_TO_STD_NAMESPACE + +_STLP_END_NAMESPACE + +#endif /* _STLP_POINTERS_SPEC_TOOLS_H */ diff --git a/WebKit/android/stlport/stl/pointers/_vector.h b/WebKit/android/stlport/stl/pointers/_vector.h new file mode 100644 index 0000000..8de4c00 --- /dev/null +++ b/WebKit/android/stlport/stl/pointers/_vector.h @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2003 + * Francois Dumont + * + * 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_SPECIALIZED_VECTOR_H +#define _STLP_SPECIALIZED_VECTOR_H + +#ifndef _STLP_POINTERS_SPEC_TOOLS_H +# include <stl/pointers/_tools.h> +#endif + +_STLP_BEGIN_NAMESPACE + +#define VECTOR_IMPL _STLP_PTR_IMPL_NAME(vector) + +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) +_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV _Vector_base<void*,allocator<void*> >; +_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV VECTOR_IMPL<void*, allocator<void*> >; +#endif + +#if defined (_STLP_DEBUG) +# define vector _STLP_NON_DBG_NAME(vector) +_STLP_MOVE_TO_PRIV_NAMESPACE +#endif + +template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) > +class vector +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (vector) + : public __stlport_class<vector<_Tp, _Alloc> > +#endif +{ + /* In the vector implementation iterators are pointer which give a number + * of opportunities for optimization. To not break those optimizations + * iterators passed to template should not be wrapped for casting purpose. + * So vector implementation will always use a qualified void pointer type and + * won't use iterator wrapping. + */ + typedef typename _STLP_PRIV _StorageType<_Tp>::_QualifiedType _StorageType; + typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc; + typedef _STLP_PRIV VECTOR_IMPL<_StorageType, _StorageTypeAlloc> _Base; + typedef vector<_Tp, _Alloc> _Self; + + typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits; + +public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef random_access_iterator_tag _Iterator_category; + + _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS; + _STLP_FORCE_ALLOCATORS(value_type, _Alloc) + typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type; + + allocator_type get_allocator() const + { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); } + + iterator begin() { return cast_traits::to_value_type_ptr(_M_impl.begin()); } + const_iterator begin() const { return cast_traits::to_value_type_cptr(_M_impl.begin()); } + iterator end() { return cast_traits::to_value_type_ptr(_M_impl.end()); } + const_iterator end() const { return cast_traits::to_value_type_cptr(_M_impl.end()); } + + reverse_iterator rbegin() { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } + reverse_iterator rend() { return reverse_iterator(begin()); } + const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } + + size_type size() const { return _M_impl.size(); } + size_type max_size() const { return _M_impl.max_size(); } + + size_type capacity() const { return _M_impl.capacity(); } + bool empty() const { return _M_impl.empty(); } + + reference operator[](size_type __n) { return cast_traits::to_value_type_ref(_M_impl[__n]); } + const_reference operator[](size_type __n) const { return cast_traits::to_value_type_cref(_M_impl[__n]); } + + reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); } + const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); } + reference back() { return cast_traits::to_value_type_ref(_M_impl.back()); } + const_reference back() const { return cast_traits::to_value_type_cref(_M_impl.back()); } + + reference at(size_type __n) { return cast_traits::to_value_type_ref(_M_impl.at(__n)); } + const_reference at(size_type __n) const { return cast_traits::to_value_type_cref(_M_impl.at(__n)); } + + explicit vector(const allocator_type& __a = allocator_type()) + : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit vector(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type), +#else + vector(size_type __n, const value_type& __val, +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + const allocator_type& __a = allocator_type()) + : _M_impl(__n, cast_traits::to_storage_type_cref(__val), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + explicit vector(size_type __n) + : _M_impl(__n, allocator_type() ) {} +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + vector(const _Self& __x) + : _M_impl(__x._M_impl) {} + + explicit vector(__move_source<_Self> src) + : _M_impl(__move_source<_Base>(src.get()._M_impl)) {} + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL ) + : _M_impl(__first, __last, + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} + +# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) + template <class _InputIterator> + vector(_InputIterator __first, _InputIterator __last) + : _M_impl(__first, __last) {} +# endif + +#else + vector(const_iterator __first, const_iterator __last, + const allocator_type& __a = allocator_type()) + : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last), + _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} +#endif /* _STLP_MEMBER_TEMPLATES */ + + _Self& operator=(const _Self& __x) { _M_impl = __x._M_impl; return *this; } + + void reserve(size_type __n) {_M_impl.reserve(__n);} + void assign(size_type __n, const value_type& __val) + { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); } + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + void assign(_InputIterator __first, _InputIterator __last) + { _M_impl.assign(__first, __last); } +#else + void assign(const_iterator __first, const_iterator __last) { + _M_impl.assign(cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } +#endif /* _STLP_MEMBER_TEMPLATES */ + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + void push_back(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void push_back(const value_type& __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + iterator insert(iterator __pos, const value_type& __x) +#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + { return cast_traits::to_value_type_ptr(_M_impl.insert(cast_traits::to_storage_type_ptr(__pos), + cast_traits::to_storage_type_cref(__x))); } + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) + void push_back() { _M_impl.push_back(); } + iterator insert(iterator __pos) + { return _M_impl.insert(cast_traits::to_storage_type_ptr(__pos)); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ + + void swap(_Self& __x) { _M_impl.swap(__x._M_impl); } + +#if defined (_STLP_MEMBER_TEMPLATES) + template <class _InputIterator> + void insert(iterator __pos, _InputIterator __first, _InputIterator __last) + { _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __first, __last); } +#else + void insert(iterator __pos, const_iterator __first, const_iterator __last) { + _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), cast_traits::to_storage_type_cptr(__first), + cast_traits::to_storage_type_cptr(__last)); + } +#endif + + void insert (iterator __pos, size_type __n, const value_type& __x) { + _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __n, cast_traits::to_storage_type_cref(__x)); + } + + void pop_back() {_M_impl.pop_back();} + iterator erase(iterator __pos) + {return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__pos)));} + iterator erase(iterator __first, iterator __last) { + return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__first), + cast_traits::to_storage_type_ptr(__last))); + } + +#if !defined(_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) +#else + void resize(size_type __new_size, const value_type& __x) +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); } + +#if defined(_STLP_DONT_SUP_DFLT_PARAM) + void resize(size_type __new_size) { _M_impl.resize(__new_size); } +#endif /*_STLP_DONT_SUP_DFLT_PARAM*/ + + void clear() { _M_impl.clear(); } + +private: + _Base _M_impl; +}; + +#if defined (vector) +# undef vector +_STLP_MOVE_TO_STD_NAMESPACE +#endif + +#undef VECTOR_IMPL + +_STLP_END_NAMESPACE + +#endif /* _STLP_SPECIALIZED_VECTOR_H */ |