+2001-12-31 Paolo Carlini <pcarlini@unitus.it>
+
+ * include/ext/hash_map: Move into __gnu_cxx,
+ tweak, add using declarations.
+ * include/ext/hash_set: Ditto.
+ * include/ext/ropeimpl.h: Ditto.
+ * include/ext/stl_hash_fun.h: Ditto.
+ * include/ext/stl_hashtable.h: Ditto.
+ * include/ext/stl_rope.h: Ditto.
+ * src/ext-inst.cc: Tweak.
+ * testsuite/ext/rope.cc: Tweak.
+
2001-12-31 Paolo Carlini <pcarlini@unitus.it>
* include/backward/algo.h: Include <ext/algorithm>,
#include <ext/stl_hashtable.h>
#include <bits/concept_check.h>
-namespace std
+namespace __gnu_cxx
{
+using std::equal_to;
+using std::allocator;
+using std::pair;
+using std::_Select1st;
// Forward declaration of equality operator; needed for friend declaration.
__hm1.swap(__hm2);
}
+} // namespace __gnu_cxx
+namespace std
+{
// Specialization of insert_iterator so that it will work for hash_map
// and hash_multimap.
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
-class insert_iterator<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
protected:
- typedef hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
_Container* container;
public:
typedef _Container container_type;
};
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
-class insert_iterator<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
protected:
- typedef hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
_Container* container;
typename _Container::iterator iter;
public:
#include <ext/stl_hashtable.h>
#include <bits/concept_check.h>
-namespace std
+namespace __gnu_cxx
{
+using std::equal_to;
+using std::allocator;
+using std::pair;
+using std::_Identity;
// Forward declaration of equality operator; needed for friend declaration.
__hs1.swap(__hs2);
}
+} // namespace __gnu_cxx
+
+namespace std
+{
// Specialization of insert_iterator so that it will work for hash_set
// and hash_multiset.
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
-class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
+class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
protected:
- typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
_Container* container;
public:
typedef _Container container_type;
};
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
-class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
+class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
protected:
- typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
_Container* container;
typename _Container::iterator iter;
public:
#include <bits/std_iostream.h>
#include <bits/functexcept.h>
-namespace std
+namespace __gnu_cxx
{
+using std::size_t;
+using std::printf;
+using std::basic_ostream;
+using std::__throw_length_error;
+using std::__alloc;
+using std::_Destroy;
+using std::uninitialized_fill_n;
+using std::lexicographical_compare_3way;
+using std::uninitialized_copy_n;
// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
// if necessary. Assumes _M_path_end[leaf_index] and leaf_pos are correct.
_RopeRep* __left = __conc->_M_left;
size_t __left_len = __left->_M_size;
if (__begin < __left_len) {
- size_t __left_end = min(__left_len, __end);
+ size_t __left_end = std::min(__left_len, __end);
if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
return false;
}
if (__end > __left_len) {
_RopeRep* __right = __conc->_M_right;
- size_t __right_start = max(__left_len, __begin);
+ size_t __right_start = std::max(__left_len, __begin);
if (!_S_apply_to_pieces(__c, __right,
__right_start - __left_len,
__end - __left_len)) {
const rope<_CharT, _Alloc>& __r)
{
size_t __w = __o.width();
- bool __left = bool(__o.flags() & ios::left);
+ bool __left = bool(__o.flags() & std::ios::left);
size_t __pad_len;
size_t __rope_len = __r.size();
_Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
case _RopeRep::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
- return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
+ return std::copy_n(__l->_M_data, __l->_M_size, __buffer).second;
}
case _RopeRep::_S_function:
case _RopeRep::_S_substringfn:
_M_tree_ptr->_M_c_string = __result;
# else
if ((__old_c_string = (__GC_CONST _CharT*)
- _Atomic_swap((unsigned long *)(&(_M_tree_ptr->_M_c_string)),
+ std::_Atomic_swap((unsigned long *)(&(_M_tree_ptr->_M_c_string)),
(unsigned long)__result)) != 0) {
// It must have been added in the interim. Hence it had to have been
// separately allocated. Deallocate the old copy, since we just
}
# endif
-} // namespace std
+} // namespace __gnu_cxx
// Local Variables:
// mode:C++
#include <bits/std_cstddef.h>
-namespace std
+namespace __gnu_cxx
{
+using std::size_t;
template <class _Key> struct hash { };
size_t operator()(unsigned long __x) const { return __x; }
};
-} // namespace std
+} // namespace __gnu_cxx
#endif /* _CPP_BITS_STL_HASH_FUN_H */
#include <bits/stl_vector.h>
#include <ext/stl_hash_fun.h>
-namespace std
+namespace __gnu_cxx
{
+using std::size_t;
+using std::ptrdiff_t;
+using std::forward_iterator_tag;
+using std::input_iterator_tag;
+using std::_Alloc_traits;
+using std::_Construct;
+using std::_Destroy;
+using std::distance;
+using std::vector;
+using std::pair;
template <class _Val>
struct _Hashtable_node
};
template <class _Val, class _Key, class _HashFcn,
- class _ExtractKey, class _EqualKey, class _Alloc = __alloc>
+ class _ExtractKey, class _EqualKey, class _Alloc = std::__alloc>
class hashtable;
template <class _Val, class _Key, class _HashFcn,
{
const unsigned long* __first = __stl_prime_list;
const unsigned long* __last = __stl_prime_list + (int)__stl_num_primes;
- const unsigned long* pos = lower_bound(__first, __last, __n);
+ const unsigned long* pos = std::lower_bound(__first, __last, __n);
return pos == __last ? *(__last - 1) : *pos;
}
}
}
-} // namespace std
+} // namespace __gnu_cxx
#endif /* __SGI_STL_INTERNAL_HASHTABLE_H */
# define __GC_CONST // constant except for deallocation
# endif
-namespace std
+namespace __gnu_cxx
{
+using std::size_t;
+using std::ptrdiff_t;
+using std::allocator;
+using std::iterator;
+using std::reverse_iterator;
+using std::_Alloc_traits;
+using std::_Destroy;
+using std::_Refcount_Base;
+using std::uninitialized_copy_n;
// The _S_eos function is used for those functions that
// convert to/from C-like strings to detect the end of the string.
// little like containers.
template<class _Sequence, size_t _Buf_sz = 100>
-class sequence_buffer : public iterator<output_iterator_tag,void,void,void,void>
+class sequence_buffer : public iterator<std::output_iterator_tag,void,void,void,void>
{
public:
typedef typename _Sequence::value_type value_type;
// The result has refcount 0.
template<class _CharT, class _Alloc>
struct _Rope_Concat_fn
- : public binary_function<rope<_CharT,_Alloc>, rope<_CharT,_Alloc>,
+ : public std::binary_function<rope<_CharT,_Alloc>, rope<_CharT,_Alloc>,
rope<_CharT,_Alloc> > {
rope<_CharT,_Alloc> operator() (const rope<_CharT,_Alloc>& __x,
const rope<_CharT,_Alloc>& __y) {
allocator_type __a)
: _Rope_RopeRep<_CharT,_Alloc>(_S_concat,
- max(__l->_M_depth, __r->_M_depth) + 1,
+ std::max(__l->_M_depth, __r->_M_depth) + 1,
false,
__l->_M_size + __r->_M_size, __a),
_M_left(__l), _M_right(__r)
template<class _CharT, class _Alloc>
class _Rope_iterator_base
- : public iterator<random_access_iterator_tag, _CharT>
+ : public iterator<std::random_access_iterator_tag, _CharT>
{
friend class rope<_CharT,_Alloc>;
public:
{
_CharT* __buf = _Data_allocate(_S_rounded_up_size(1));
- _Construct(__buf, __c);
+ std::_Construct(__buf, __c);
try {
_M_tree_ptr = _S_new_RopeLeaf(__buf, 1, __a);
}
size_type find(_CharT __c, size_type __pos = 0) const;
size_type find(const _CharT* __s, size_type __pos = 0) const {
size_type __result_pos;
- const_iterator __result = search(const_begin() + __pos, const_end(),
- __s, __s + _S_char_ptr_len(__s));
+ const_iterator __result =
+ std::search(const_begin() + __pos, const_end(),
+ __s, __s + _S_char_ptr_len(__s));
__result_pos = __result.index();
# ifndef __STL_OLD_ROPE_SEMANTICS
if (__result_pos == size()) __result_pos = npos;
}
template<class _CharT, class _Traits, class _Alloc>
-basic_ostream<_CharT, _Traits>& operator<<
- (basic_ostream<_CharT, _Traits>& __o,
+std::basic_ostream<_CharT, _Traits>& operator<<
+ (std::basic_ostream<_CharT, _Traits>& __o,
const rope<_CharT, _Alloc>& __r);
typedef rope<char> crope;
}
};
-} // namespace std
+} // namespace __gnu_cxx
# include <ext/ropeimpl.h>
namespace std
{
- template const unsigned long rope<char, std::allocator<char> >::_S_min_len;
+ template
+ const unsigned long __gnu_cxx::rope<char, std::allocator<char> >::_S_min_len;
} // namespace std
void test01()
{
- std::crope foo;
+ __gnu_cxx::crope foo;
foo += "bar";
const char* data = foo.c_str();
std::cout << data << std::endl;
projects / thirdparty / gcc.git / commitdiff
