Skip to content

R
riscv-gcc-1
Commit 15d72060 by Paolo Carlini Committed by Paolo Carlini
Options

stl_construct.h: Wrap overlong lines, reformat according to the coding standards. 

2004-02-06  Paolo Carlini  <pcarlini@suse.de>

	* include/bits/stl_construct.h: Wrap overlong lines, reformat
	according to the coding standards.
	* include/bits/stl_pair.h: Likewise.
	* include/bits/stl_raw_storage_iter.h: Likewise.
	* include/bits/stl_stack.h: Likewise.
	* include/bits/stl_uninitialized.h: Likewise.
	* include/bits/stream_iterator.h: Likewise.
	* include/bits/streambuf_iterator.h: Likewise.
	* include/bits/type_traits.h: Likewise.

From-SVN: r77425
parent 0a2d3d69
Showing with 262 additions and 167 deletions
libstdc++-v3/ChangeLog
2004-02-06 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_construct.h: Wrap overlong lines, reformat
according to the coding standards.
* include/bits/stl_pair.h: Likewise.
* include/bits/stl_raw_storage_iter.h: Likewise.
* include/bits/stl_stack.h: Likewise.
* include/bits/stl_uninitialized.h: Likewise.
* include/bits/stream_iterator.h: Likewise.
* include/bits/streambuf_iterator.h: Likewise.
* include/bits/type_traits.h: Likewise.
2004-02-06 Paolo Carlini <pcarlini@suse.de>
* testsuite/27_io/basic_filebuf/open/char/9507.cc:
Adjust timings.
......
libstdc++-v3/include/bits/stl_construct.h
// nonstandard construct and destroy functions -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -115,7 +115,8 @@ namespace std
*/
template<typename _ForwardIterator>
inline void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
__false_type)
{ for ( ; __first != __last; ++__first) std::_Destroy(&*__first); }
/**
......
libstdc++-v3/include/bits/stl_pair.h
// Pair implementation -*- C++ -*-
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -64,68 +64,71 @@
namespace std
{
/// pair holds two objects of arbitrary type.
template <class _T1, class _T2>
struct pair {
/// pair holds two objects of arbitrary type.
template <class _T1, class _T2>
struct pair
{
typedef _T1 first_type; ///< @c first_type is the first bound type
typedef _T2 second_type; ///< @c second_type is the second bound type
_T1 first; ///< @c first is a copy of the first object
_T2 second; ///< @c second is a copy of the second object
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 265. std::pair::pair() effects overly restrictive
/** The default constructor creates @c first and @c second using their
* respective default constructors. */
pair() : first(), second() {}
pair()
: first(), second() {}
/** Two objects may be passed to a @c pair constructor to be copied. */
pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}
pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) {}
/** There is also a templated copy ctor for the @c pair class itself. */
template <class _U1, class _U2>
pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
};
/// Two pairs of the same type are equal iff their members are equal.
template <class _T1, class _T2>
inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
return __x.first == __y.first && __x.second == __y.second;
}
/// <http://gcc.gnu.org/onlinedocs/libstdc++/20_util/howto.html#pairlt>
template <class _T1, class _T2>
inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
return __x.first < __y.first ||
(!(__y.first < __x.first) && __x.second < __y.second);
}
/// Uses @c operator== to find the result.
template <class _T1, class _T2>
inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
return !(__x == __y);
}
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
return __y < __x;
}
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
return !(__y < __x);
}
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
return !(__x < __y);
}
/**
pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) {}
};
/// Two pairs of the same type are equal iff their members are equal.
template <class _T1, class _T2>
inline bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
/// <http://gcc.gnu.org/onlinedocs/libstdc++/20_util/howto.html#pairlt>
template <class _T1, class _T2>
inline bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
/// Uses @c operator== to find the result.
template <class _T1, class _T2>
inline bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
/// Uses @c operator< to find the result.
template <class _T1, class _T2>
inline bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
/**
* @brief A convenience wrapper for creating a pair from two objects.
* @param x The first object.
* @param y The second object.
......@@ -134,14 +137,14 @@ inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
* The standard requires that the objects be passed by reference-to-const,
* but LWG issue #181 says they should be passed by const value. We follow
* the LWG by default.
*/
template <class _T1, class _T2>
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y)
{
return pair<_T1, _T2>(__x, __y);
}
*/
template <class _T1, class _T2>
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
inline pair<_T1, _T2>
make_pair(_T1 __x, _T2 __y)
{ return pair<_T1, _T2>(__x, __y); }
} // namespace std
......
libstdc++-v3/include/bits/stl_raw_storage_iter.h
// -*- C++ -*-
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -76,7 +76,8 @@ namespace std
public:
explicit
raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
raw_storage_iterator(_ForwardIterator __x)
: _M_iter(__x) {}
raw_storage_iterator&
operator*() { return *this; }
......
libstdc++-v3/include/bits/stl_stack.h
// Stack implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -79,7 +79,6 @@ namespace std
inline bool
operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
/**
* @brief A standard container giving FILO behavior.
*
......@@ -141,17 +140,20 @@ namespace std
* @brief Default constructor creates no elements.
*/
explicit
stack(const _Sequence& __c = _Sequence()) : c(__c) {}
stack(const _Sequence& __c = _Sequence())
: c(__c) {}
/**
* Returns true if the %stack is empty.
*/
bool
empty() const { return c.empty(); }
empty() const
{ return c.empty(); }
/** Returns the number of elements in the %stack. */
size_type
size() const { return c.size(); }
size() const
{ return c.size(); }
/**
* Returns a read/write reference to the data at the first
......@@ -185,7 +187,8 @@ namespace std
* underlying sequence.
*/
void
push(const value_type& __x) { c.push_back(__x); }
push(const value_type& __x)
{ c.push_back(__x); }
/**
* @brief Removes first element.
......@@ -206,7 +209,6 @@ namespace std
}
};
/**
* @brief Stack equality comparison.
* @param x A %stack.
......@@ -221,7 +223,7 @@ namespace std
*/
template<typename _Tp, typename _Seq>
inline bool
operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return __x.c == __y.c; }
/**
......@@ -239,31 +241,31 @@ namespace std
*/
template<typename _Tp, typename _Seq>
inline bool
operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return __x.c < __y.c; }
/// Based on operator==
template<typename _Tp, typename _Seq>
inline bool
operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return !(__x == __y); }
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return __y < __x; }
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return !(__y < __x); }
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
{ return !(__x < __y); }
} // namespace std
......
libstdc++-v3/include/bits/stl_uninitialized.h
// Raw memory manipulators -*- C++ -*-
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -109,7 +109,8 @@ namespace std
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
return std::__uninitialized_copy_aux(__first, __last, __result, _Is_POD());
return std::__uninitialized_copy_aux(__first, __last, __result,
_Is_POD());
}
inline char*
......@@ -138,12 +139,12 @@ namespace std
template<typename _ForwardIterator, typename _Tp>
void
__uninitialized_fill_aux(_ForwardIterator __first,
_ForwardIterator __last,
__uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, __false_type)
{
_ForwardIterator __cur = __first;
try {
try
{
for ( ; __cur != __last; ++__cur)
std::_Construct(&*__cur, __x);
}
......@@ -235,8 +236,10 @@ namespace std
_InputIterator2 __last2,
_ForwardIterator __result)
{
_ForwardIterator __mid = std::uninitialized_copy(__first1, __last1, __result);
try {
_ForwardIterator __mid = std::uninitialized_copy(__first1, __last1,
__result);
try
{
return std::uninitialized_copy(__first2, __last2, __mid);
}
catch(...)
......@@ -252,11 +255,12 @@ namespace std
template<typename _ForwardIterator, typename _Tp, typename _InputIterator>
inline _ForwardIterator
__uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x,
_InputIterator __first, _InputIterator __last)
const _Tp& __x, _InputIterator __first,
_InputIterator __last)
{
std::uninitialized_fill(__result, __mid, __x);
try {
try
{
return std::uninitialized_copy(__first, __last, __mid);
}
catch(...)
......@@ -272,8 +276,8 @@ namespace std
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
inline void
__uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
const _Tp& __x)
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x)
{
_ForwardIterator __mid2 = std::uninitialized_copy(__first1, __last1,
__first2);
......
libstdc++-v3/include/bits/stream_iterator.h
......@@ -59,10 +59,13 @@ namespace std
public:
/// Construct end of input stream iterator.
istream_iterator() : _M_stream(0), _M_ok(false) {}
istream_iterator()
: _M_stream(0), _M_ok(false) {}
/// Construct start of input stream iterator.
istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }
istream_iterator(istream_type& __s)
: _M_stream(&__s)
{ _M_read(); }
istream_iterator(const istream_iterator& __obj)
: _M_stream(__obj._M_stream), _M_value(__obj._M_value),
......@@ -104,7 +107,7 @@ namespace std
bool
_M_equal(const istream_iterator& __x) const
{ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);}
{ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
private:
void
......@@ -133,7 +136,6 @@ namespace std
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
{ return !__x._M_equal(__y); }
/**
* @brief Provides output iterator semantics for streams.
*
......@@ -197,13 +199,16 @@ namespace std
}
ostream_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
ostream_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
ostream_iterator&
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
} // namespace std
#endif
libstdc++-v3/include/bits/streambuf_iterator.h
......@@ -159,8 +159,8 @@ namespace std
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else
if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
else if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_sbuf = 0;
}
return __ret;
......@@ -248,7 +248,8 @@ namespace std
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false))
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
......
libstdc++-v3/include/bits/type_traits.h
// Type traits implementation -*- C++ -*-
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
......@@ -91,7 +91,8 @@ struct __true_type {};
struct __false_type {};
template <class _Tp>
struct __type_traits {
struct __type_traits
{
typedef __true_type this_dummy_member_must_be_first;
/* Do not remove this member. It informs a compiler which
automatically specializes __type_traits that this
......@@ -115,222 +116,287 @@ struct __type_traits {
typedef __false_type has_trivial_assignment_operator;
typedef __false_type has_trivial_destructor;
typedef __false_type is_POD_type;
};
};
// Provide some specializations.
template<> struct __type_traits<bool> {
template<>
struct __type_traits<bool>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<char> {
template<>
struct __type_traits<char>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<signed char> {
template<>
struct __type_traits<signed char>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<unsigned char> {
template<>
struct __type_traits<unsigned char>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<wchar_t> {
template<>
struct __type_traits<wchar_t>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<short> {
template<>
struct __type_traits<short>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<unsigned short> {
template<>
struct __type_traits<unsigned short>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<int> {
template<>
struct __type_traits<int>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<unsigned int> {
template<>
struct __type_traits<unsigned int>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<long> {
template<>
struct __type_traits<long>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<unsigned long> {
template<>
struct __type_traits<unsigned long>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<long long> {
template<>
struct __type_traits<long long>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<unsigned long long> {
template<>
struct __type_traits<unsigned long long>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<float> {
template<>
struct __type_traits<float>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<double> {
template<>
struct __type_traits<double>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template<> struct __type_traits<long double> {
template<>
struct __type_traits<long double>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
template <class _Tp>
struct __type_traits<_Tp*> {
struct __type_traits<_Tp*>
{
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
};
// The following could be written in terms of numeric_limits.
// We're doing it separately to reduce the number of dependencies.
template <class _Tp> struct _Is_integer {
template <class _Tp>
struct _Is_integer
{
typedef __false_type _Integral;
};
};
template<> struct _Is_integer<bool> {
template<>
struct _Is_integer<bool>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<char> {
template<>
struct _Is_integer<char>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<signed char> {
template<>
struct _Is_integer<signed char>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<unsigned char> {
template<>
struct _Is_integer<unsigned char>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<wchar_t> {
template<>
struct _Is_integer<wchar_t>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<short> {
template<>
struct _Is_integer<short>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<unsigned short> {
template<>
struct _Is_integer<unsigned short>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<int> {
template<>
struct _Is_integer<int>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<unsigned int> {
template<>
struct _Is_integer<unsigned int>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<long> {
template<>
struct _Is_integer<long>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<unsigned long> {
template<>
struct _Is_integer<unsigned long>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<long long> {
template<>
struct _Is_integer<long long>
{
typedef __true_type _Integral;
};
};
template<> struct _Is_integer<unsigned long long> {
template<>
struct _Is_integer<unsigned long long>
{
typedef __true_type _Integral;
};
};
template<typename _Tp> struct _Is_normal_iterator {
template<typename _Tp>
struct _Is_normal_iterator
{
typedef __false_type _Normal;
};
};
// Forward declaration hack, should really include this from somewhere.
namespace __gnu_cxx
{
template<typename _Iterator, typename _Container> class __normal_iterator;
template<typename _Iterator, typename _Container>
class __normal_iterator;
}
template<typename _Iterator, typename _Container>
struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, _Container> > {
struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
typedef __true_type _Normal;
};
};
#endif /* _TYPE_TRAITS_H */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment