Initial commit
This commit is contained in:
Eagle517
75
TBE/MinGW/include/c++/3.2.3/algorithm
Normal file
75
TBE/MinGW/include/c++/3.2.3/algorithm
Normal file
@@ -0,0 +1,75 @@
|
||||
// <algorithm> -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file algorithm
|
||||
* This is a Standard C++ Library header. You should @c #include this header
|
||||
* in your programs, rather than any of the "st[dl]_*.h" implementation files.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_ALGORITHM
|
||||
#define _CPP_ALGORITHM 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/stl_algobase.h>
|
||||
#include <bits/stl_construct.h>
|
||||
#include <bits/stl_uninitialized.h>
|
||||
#include <bits/stl_algo.h>
|
||||
|
||||
#endif /* _CPP_ALGORITHM */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
149
TBE/MinGW/include/c++/3.2.3/backward/algo.h
Normal file
149
TBE/MinGW/include/c++/3.2.3/backward/algo.h
Normal file
@@ -0,0 +1,149 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_ALGO_H
|
||||
#define _CPP_BACKWARD_ALGO_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include "tempbuf.h"
|
||||
#include "iterator.h"
|
||||
#include <bits/stl_algo.h>
|
||||
#include <bits/stl_numeric.h>
|
||||
#include <ext/algorithm>
|
||||
#include <ext/numeric>
|
||||
|
||||
// Names from <stl_algo.h>
|
||||
using std::for_each;
|
||||
using std::find;
|
||||
using std::find_if;
|
||||
using std::adjacent_find;
|
||||
using std::count;
|
||||
using std::count_if;
|
||||
using std::search;
|
||||
using std::search_n;
|
||||
using std::swap_ranges;
|
||||
using std::transform;
|
||||
using std::replace;
|
||||
using std::replace_if;
|
||||
using std::replace_copy;
|
||||
using std::replace_copy_if;
|
||||
using std::generate;
|
||||
using std::generate_n;
|
||||
using std::remove;
|
||||
using std::remove_if;
|
||||
using std::remove_copy;
|
||||
using std::remove_copy_if;
|
||||
using std::unique;
|
||||
using std::unique_copy;
|
||||
using std::reverse;
|
||||
using std::reverse_copy;
|
||||
using std::rotate;
|
||||
using std::rotate_copy;
|
||||
using std::random_shuffle;
|
||||
using std::partition;
|
||||
using std::stable_partition;
|
||||
using std::sort;
|
||||
using std::stable_sort;
|
||||
using std::partial_sort;
|
||||
using std::partial_sort_copy;
|
||||
using std::nth_element;
|
||||
using std::lower_bound;
|
||||
using std::upper_bound;
|
||||
using std::equal_range;
|
||||
using std::binary_search;
|
||||
using std::merge;
|
||||
using std::inplace_merge;
|
||||
using std::includes;
|
||||
using std::set_union;
|
||||
using std::set_intersection;
|
||||
using std::set_difference;
|
||||
using std::set_symmetric_difference;
|
||||
using std::min_element;
|
||||
using std::max_element;
|
||||
using std::next_permutation;
|
||||
using std::prev_permutation;
|
||||
using std::find_first_of;
|
||||
using std::find_end;
|
||||
|
||||
// Names from stl_heap.h
|
||||
using std::push_heap;
|
||||
using std::pop_heap;
|
||||
using std::make_heap;
|
||||
using std::sort_heap;
|
||||
|
||||
// Names from stl_numeric.h
|
||||
using std::accumulate;
|
||||
using std::inner_product;
|
||||
using std::partial_sum;
|
||||
using std::adjacent_difference;
|
||||
|
||||
// Names from ext/algorithm
|
||||
using __gnu_cxx::random_sample;
|
||||
using __gnu_cxx::random_sample_n;
|
||||
using __gnu_cxx::is_sorted;
|
||||
using __gnu_cxx::is_heap;
|
||||
using __gnu_cxx::count; // Extension returning void
|
||||
using __gnu_cxx::count_if; // Extension returning void
|
||||
|
||||
// Names from ext/numeric
|
||||
using __gnu_cxx::power;
|
||||
using __gnu_cxx::iota;
|
||||
|
||||
#endif /* _CPP_BACKWARD_ALGO_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
95
TBE/MinGW/include/c++/3.2.3/backward/algobase.h
Normal file
95
TBE/MinGW/include/c++/3.2.3/backward/algobase.h
Normal file
@@ -0,0 +1,95 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_ALGOBASE_H
|
||||
#define _CPP_BACKWARD_ALGOBASE_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "pair.h"
|
||||
#include "iterator.h"
|
||||
#include <bits/stl_algobase.h>
|
||||
#include <bits/stl_uninitialized.h>
|
||||
#include <ext/algorithm>
|
||||
#include <ext/memory>
|
||||
|
||||
// Names from stl_algobase.h
|
||||
using std::iter_swap;
|
||||
using std::swap;
|
||||
using std::min;
|
||||
using std::max;
|
||||
using std::copy;
|
||||
using std::copy_backward;
|
||||
using std::fill;
|
||||
using std::fill_n;
|
||||
using std::mismatch;
|
||||
using std::equal;
|
||||
using std::lexicographical_compare;
|
||||
|
||||
// Names from stl_uninitialized.h
|
||||
using std::uninitialized_copy;
|
||||
using std::uninitialized_fill;
|
||||
using std::uninitialized_fill_n;
|
||||
|
||||
// Names from ext/algorithm
|
||||
using __gnu_cxx::copy_n;
|
||||
using __gnu_cxx::lexicographical_compare_3way;
|
||||
|
||||
// Names from ext/memory
|
||||
using __gnu_cxx::uninitialized_copy_n;
|
||||
|
||||
#endif /* _CPP_BACKWARD_ALGOBASE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
58
TBE/MinGW/include/c++/3.2.3/backward/alloc.h
Normal file
58
TBE/MinGW/include/c++/3.2.3/backward/alloc.h
Normal file
@@ -0,0 +1,58 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996-1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_ALLOC_H
|
||||
#define _CPP_BACKWARD_ALLOC_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <bits/c++config.h>
|
||||
#include <bits/stl_alloc.h>
|
||||
|
||||
using std::__malloc_alloc_template;
|
||||
using std::__simple_alloc;
|
||||
using std::__debug_alloc;
|
||||
using std::__alloc;
|
||||
using std::__single_client_alloc;
|
||||
using std::allocator;
|
||||
using std::__default_alloc_template;
|
||||
|
||||
#endif
|
||||
39
TBE/MinGW/include/c++/3.2.3/backward/backward_warning.h
Normal file
39
TBE/MinGW/include/c++/3.2.3/backward/backward_warning.h
Normal file
@@ -0,0 +1,39 @@
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_BACKWARD_WARNING_H
|
||||
#define _CPP_BACKWARD_BACKWARD_WARNING_H 1
|
||||
|
||||
#ifdef __DEPRECATED
|
||||
#warning This file includes at least one deprecated or antiquated header. \
|
||||
Please consider using one of the 32 headers found in section 17.4.1.2 of the \
|
||||
C++ standard. Examples include substituting the <X> header for the <X.h> \
|
||||
header for C++ includes, or <sstream> instead of the deprecated header \
|
||||
<strstream.h>. To disable this warning use -Wno-deprecated.
|
||||
#endif
|
||||
|
||||
#endif
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/bvector.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/bvector.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef __SGI_STL_BVECTOR_H
|
||||
#define __SGI_STL_BVECTOR_H
|
||||
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <vector>
|
||||
|
||||
using std::bit_vector;
|
||||
|
||||
#endif /* __SGI_STL_BVECTOR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
43
TBE/MinGW/include/c++/3.2.3/backward/complex.h
Normal file
43
TBE/MinGW/include/c++/3.2.3/backward/complex.h
Normal file
@@ -0,0 +1,43 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_COMPLEX_H
|
||||
#define _CPP_BACKWARD_COMPLEX_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <complex>
|
||||
|
||||
using std::complex;
|
||||
typedef complex<float> float_complex;
|
||||
typedef complex<double> double_complex;
|
||||
typedef complex<long double> long_double_complex;
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
117
TBE/MinGW/include/c++/3.2.3/backward/defalloc.h
Normal file
117
TBE/MinGW/include/c++/3.2.3/backward/defalloc.h
Normal file
@@ -0,0 +1,117 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
// Inclusion of this file is DEPRECATED. This is the original HP
|
||||
// default allocator. It is provided only for backward compatibility.
|
||||
// This file WILL BE REMOVED in a future release.
|
||||
//
|
||||
// DO NOT USE THIS FILE unless you have an old container implementation
|
||||
// that requires an allocator with the HP-style interface.
|
||||
//
|
||||
// Standard-conforming allocators have a very different interface. The
|
||||
// standard default allocator is declared in the header <memory>.
|
||||
|
||||
#ifndef _CPP_BACKWARD_DEFALLOC_H
|
||||
#define _CPP_BACKWARD_DEFALLOC_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "new.h"
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include "iostream.h"
|
||||
#include "algobase.h"
|
||||
|
||||
|
||||
template <class _Tp>
|
||||
inline _Tp* allocate(ptrdiff_t __size, _Tp*) {
|
||||
set_new_handler(0);
|
||||
_Tp* __tmp = (_Tp*)(::operator new((size_t)(__size * sizeof(_Tp))));
|
||||
if (__tmp == 0) {
|
||||
cerr << "out of memory" << endl;
|
||||
exit(1);
|
||||
}
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
|
||||
template <class _Tp>
|
||||
inline void deallocate(_Tp* __buffer) {
|
||||
::operator delete(__buffer);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
class allocator {
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef const _Tp* const_pointer;
|
||||
typedef _Tp& reference;
|
||||
typedef const _Tp& const_reference;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
pointer allocate(size_type __n) {
|
||||
return ::allocate((difference_type)__n, (pointer)0);
|
||||
}
|
||||
void deallocate(pointer __p) { ::deallocate(__p); }
|
||||
pointer address(reference __x) { return (pointer)&__x; }
|
||||
const_pointer const_address(const_reference __x) {
|
||||
return (const_pointer)&__x;
|
||||
}
|
||||
size_type init_page_size() {
|
||||
return max(size_type(1), size_type(4096/sizeof(_Tp)));
|
||||
}
|
||||
size_type max_size() const {
|
||||
return max(size_type(1), size_type(UINT_MAX/sizeof(_Tp)));
|
||||
}
|
||||
};
|
||||
|
||||
class allocator<void> {
|
||||
public:
|
||||
typedef void* pointer;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif /* _CPP_BACKWARD_DEFALLOC_H */
|
||||
70
TBE/MinGW/include/c++/3.2.3/backward/deque.h
Normal file
70
TBE/MinGW/include/c++/3.2.3/backward/deque.h
Normal file
@@ -0,0 +1,70 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_DEQUE_H
|
||||
#define _CPP_BACKWARD_DEQUE_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include "alloc.h"
|
||||
#include <deque>
|
||||
|
||||
using std::deque;
|
||||
|
||||
#endif /* _CPP_BACKWARD_DEQUE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
52
TBE/MinGW/include/c++/3.2.3/backward/fstream.h
Normal file
52
TBE/MinGW/include/c++/3.2.3/backward/fstream.h
Normal file
@@ -0,0 +1,52 @@
|
||||
// Copyright (C) 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_FSTREAM_H
|
||||
#define _CPP_BACKWARD_FSTREAM_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <fstream>
|
||||
|
||||
using std::filebuf;
|
||||
using std::ifstream;
|
||||
using std::ofstream;
|
||||
using std::fstream;
|
||||
using std::streampos;
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
using std::wfilebuf;
|
||||
using std::wifstream;
|
||||
using std::wofstream;
|
||||
using std::wfstream;
|
||||
using std::wstreampos;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
130
TBE/MinGW/include/c++/3.2.3/backward/function.h
Normal file
130
TBE/MinGW/include/c++/3.2.3/backward/function.h
Normal file
@@ -0,0 +1,130 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_FUNCTION_H
|
||||
#define _CPP_BACKWARD_FUNCTION_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <bits/c++config.h>
|
||||
#include <stddef.h>
|
||||
#include <bits/stl_function.h>
|
||||
#include <ext/functional>
|
||||
|
||||
// Names from stl_function.h
|
||||
using std::unary_function;
|
||||
using std::binary_function;
|
||||
using std::plus;
|
||||
using std::minus;
|
||||
using std::multiplies;
|
||||
using std::divides;
|
||||
using std::modulus;
|
||||
using std::negate;
|
||||
using std::equal_to;
|
||||
using std::not_equal_to;
|
||||
using std::greater;
|
||||
using std::less;
|
||||
using std::greater_equal;
|
||||
using std::less_equal;
|
||||
using std::logical_and;
|
||||
using std::logical_or;
|
||||
using std::logical_not;
|
||||
using std::unary_negate;
|
||||
using std::binary_negate;
|
||||
using std::not1;
|
||||
using std::not2;
|
||||
using std::binder1st;
|
||||
using std::binder2nd;
|
||||
using std::bind1st;
|
||||
using std::bind2nd;
|
||||
using std::pointer_to_unary_function;
|
||||
using std::pointer_to_binary_function;
|
||||
using std::ptr_fun;
|
||||
using std::mem_fun_t;
|
||||
using std::const_mem_fun_t;
|
||||
using std::mem_fun_ref_t;
|
||||
using std::const_mem_fun_ref_t;
|
||||
using std::mem_fun1_t;
|
||||
using std::const_mem_fun1_t;
|
||||
using std::mem_fun1_ref_t;
|
||||
using std::const_mem_fun1_ref_t;
|
||||
using std::mem_fun;
|
||||
using std::mem_fun_ref;
|
||||
|
||||
// Names from ext/functional
|
||||
using __gnu_cxx::identity_element;
|
||||
using __gnu_cxx::unary_compose;
|
||||
using __gnu_cxx::binary_compose;
|
||||
using __gnu_cxx::compose1;
|
||||
using __gnu_cxx::compose2;
|
||||
using __gnu_cxx::identity;
|
||||
using __gnu_cxx::select1st;
|
||||
using __gnu_cxx::select2nd;
|
||||
using __gnu_cxx::project1st;
|
||||
using __gnu_cxx::project2nd;
|
||||
using __gnu_cxx::constant_void_fun;
|
||||
using __gnu_cxx::constant_unary_fun;
|
||||
using __gnu_cxx::constant_binary_fun;
|
||||
using __gnu_cxx::constant0;
|
||||
using __gnu_cxx::constant1;
|
||||
using __gnu_cxx::constant2;
|
||||
using __gnu_cxx::subtractive_rng;
|
||||
using __gnu_cxx::mem_fun1;
|
||||
using __gnu_cxx::mem_fun1_ref;
|
||||
|
||||
#endif /* _CPP_BACKWARD_FUNCTION_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
72
TBE/MinGW/include/c++/3.2.3/backward/hash_map.h
Normal file
72
TBE/MinGW/include/c++/3.2.3/backward/hash_map.h
Normal file
@@ -0,0 +1,72 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_HASH_MAP_H
|
||||
#define _CPP_BACKWARD_HASH_MAP_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include <ext/hash_map>
|
||||
|
||||
using __gnu_cxx::hash;
|
||||
using __gnu_cxx::hashtable;
|
||||
using __gnu_cxx::hash_map;
|
||||
using __gnu_cxx::hash_multimap;
|
||||
|
||||
#endif /* _CPP_BACKWARD_HASH_MAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/hash_set.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/hash_set.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_HASH_SET_H
|
||||
#define _CPP_BACKWARD_HASH_SET_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include <ext/hash_set>
|
||||
|
||||
using __gnu_cxx::hash;
|
||||
using __gnu_cxx::hashtable;
|
||||
using __gnu_cxx::hash_set;
|
||||
using __gnu_cxx::hash_multiset;
|
||||
|
||||
#endif /* _CPP_BACKWARD_HASH_SET_H */
|
||||
|
||||
76
TBE/MinGW/include/c++/3.2.3/backward/hashtable.h
Normal file
76
TBE/MinGW/include/c++/3.2.3/backward/hashtable.h
Normal file
@@ -0,0 +1,76 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
/* NOTE: This is an internal header file, included by other STL headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_HASHTABLE_H
|
||||
#define _CPP_BACKWARD_HASHTABLE_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <ext/stl_hashtable.h>
|
||||
#include "algo.h"
|
||||
#include "alloc.h"
|
||||
#include "vector.h"
|
||||
|
||||
using __gnu_cxx::hash;
|
||||
using __gnu_cxx::hashtable;
|
||||
|
||||
#endif /* _CPP_BACKWARD_HASHTABLE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
71
TBE/MinGW/include/c++/3.2.3/backward/heap.h
Normal file
71
TBE/MinGW/include/c++/3.2.3/backward/heap.h
Normal file
@@ -0,0 +1,71 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_HEAP_H
|
||||
#define _CPP_BACKWARD_HEAP_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <bits/c++config.h>
|
||||
#include <bits/stl_heap.h>
|
||||
|
||||
using std::push_heap;
|
||||
using std::pop_heap;
|
||||
using std::make_heap;
|
||||
using std::sort_heap;
|
||||
|
||||
#endif /* _CPP_BACKWARD_HEAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
70
TBE/MinGW/include/c++/3.2.3/backward/iomanip.h
Normal file
70
TBE/MinGW/include/c++/3.2.3/backward/iomanip.h
Normal file
@@ -0,0 +1,70 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_IOMANIP_H
|
||||
#define _CPP_BACKWARD_IOMANIP_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "iostream.h"
|
||||
#include <iomanip>
|
||||
|
||||
// These are from <ios> as per [27.4].
|
||||
using std::boolalpha;
|
||||
using std::noboolalpha;
|
||||
using std::showbase;
|
||||
using std::noshowbase;
|
||||
using std::showpoint;
|
||||
using std::noshowpoint;
|
||||
using std::showpos;
|
||||
using std::noshowpos;
|
||||
using std::skipws;
|
||||
using std::noskipws;
|
||||
using std::uppercase;
|
||||
using std::nouppercase;
|
||||
using std::internal;
|
||||
using std::left;
|
||||
using std::right;
|
||||
using std::dec;
|
||||
using std::hex;
|
||||
using std::oct;
|
||||
using std::fixed;
|
||||
using std::scientific;
|
||||
|
||||
// These are from <iomanip> as per [27.6]. Manipulators from <istream>
|
||||
// and <ostream> (e.g., endl) are made available via <iostream.h>.
|
||||
using std::resetiosflags;
|
||||
using std::setiosflags;
|
||||
using std::setbase;
|
||||
using std::setfill;
|
||||
using std::setprecision;
|
||||
using std::setw;
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
60
TBE/MinGW/include/c++/3.2.3/backward/iostream.h
Normal file
60
TBE/MinGW/include/c++/3.2.3/backward/iostream.h
Normal file
@@ -0,0 +1,60 @@
|
||||
// Copyright (C) 1997-1999, 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_IOSTREAM_H
|
||||
#define _CPP_BACKWARD_IOSTREAM_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <iostream>
|
||||
|
||||
using std::iostream;
|
||||
using std::ostream;
|
||||
using std::istream;
|
||||
using std::ios;
|
||||
using std::streambuf;
|
||||
|
||||
using std::cout;
|
||||
using std::cin;
|
||||
using std::cerr;
|
||||
using std::clog;
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
using std::wcout;
|
||||
using std::wcin;
|
||||
using std::wcerr;
|
||||
using std::wclog;
|
||||
#endif
|
||||
|
||||
using std::ws;
|
||||
using std::endl;
|
||||
using std::ends;
|
||||
using std::flush;
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
43
TBE/MinGW/include/c++/3.2.3/backward/istream.h
Normal file
43
TBE/MinGW/include/c++/3.2.3/backward/istream.h
Normal file
@@ -0,0 +1,43 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_ISTREAM_H
|
||||
#define _CPP_BACKWARD_ISTREAM_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "iostream.h"
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
162
TBE/MinGW/include/c++/3.2.3/backward/iterator.h
Normal file
162
TBE/MinGW/include/c++/3.2.3/backward/iterator.h
Normal file
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_ITERATOR_H
|
||||
#define _CPP_BACKWARD_ITERATOR_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "function.h"
|
||||
#include <stddef.h>
|
||||
#include "iostream.h"
|
||||
#include <iterator>
|
||||
|
||||
#include <bits/stl_construct.h>
|
||||
#include <bits/stl_raw_storage_iter.h>
|
||||
|
||||
#include <ext/iterator> // For 3-parameter distance extension
|
||||
|
||||
// Names from stl_iterator.h
|
||||
using std::input_iterator_tag;
|
||||
using std::output_iterator_tag;
|
||||
using std::forward_iterator_tag;
|
||||
using std::bidirectional_iterator_tag;
|
||||
using std::random_access_iterator_tag;
|
||||
|
||||
#if 0
|
||||
using std::iterator;
|
||||
#endif
|
||||
|
||||
// The base classes input_iterator, output_iterator, forward_iterator,
|
||||
// bidirectional_iterator, and random_access_iterator are not part of
|
||||
// the C++ standard. (They have been replaced by struct iterator.)
|
||||
// They are included for backward compatibility with the HP STL.
|
||||
template<typename _Tp, typename _Distance>
|
||||
struct input_iterator {
|
||||
typedef input_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef _Distance difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef _Tp& reference;
|
||||
};
|
||||
|
||||
struct output_iterator {
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Distance>
|
||||
struct forward_iterator {
|
||||
typedef forward_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef _Distance difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef _Tp& reference;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Distance>
|
||||
struct bidirectional_iterator {
|
||||
typedef bidirectional_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef _Distance difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef _Tp& reference;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Distance>
|
||||
struct random_access_iterator {
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef _Distance difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef _Tp& reference;
|
||||
};
|
||||
|
||||
using std::iterator_traits;
|
||||
|
||||
template <class _Iter>
|
||||
inline typename iterator_traits<_Iter>::iterator_category
|
||||
iterator_category(const _Iter& __i)
|
||||
{ return __iterator_category(__i); }
|
||||
|
||||
template <class _Iter>
|
||||
inline typename iterator_traits<_Iter>::difference_type*
|
||||
distance_type(const _Iter&)
|
||||
{ return static_cast<typename iterator_traits<_Iter>::difference_type*>(0); }
|
||||
|
||||
template<class _Iter>
|
||||
inline typename iterator_traits<_Iter>::value_type*
|
||||
value_type(const _Iter& __i)
|
||||
{ return static_cast<typename iterator_traits<_Iter>::value_type*>(0); }
|
||||
|
||||
using std::distance;
|
||||
using __gnu_cxx::distance; // 3-parameter extension
|
||||
using std::advance;
|
||||
|
||||
using std::insert_iterator;
|
||||
using std::front_insert_iterator;
|
||||
using std::back_insert_iterator;
|
||||
using std::inserter;
|
||||
using std::front_inserter;
|
||||
using std::back_inserter;
|
||||
|
||||
using std::reverse_iterator;
|
||||
|
||||
using std::istream_iterator;
|
||||
using std::ostream_iterator;
|
||||
|
||||
// Names from stl_construct.h
|
||||
template<class _T1, class _T2>
|
||||
inline void
|
||||
construct(_T1* __p, const _T2& __value)
|
||||
{ std::_Construct(__p, __value); }
|
||||
|
||||
template<class _T1>
|
||||
inline void
|
||||
construct(_T1* __p)
|
||||
{ std::_Construct(__p); }
|
||||
|
||||
template <class _Tp>
|
||||
inline void
|
||||
destroy(_Tp* __pointer)
|
||||
{ std::_Destroy(__pointer); }
|
||||
|
||||
template <class _ForwardIterator>
|
||||
inline void
|
||||
destroy(_ForwardIterator __first, _ForwardIterator __last)
|
||||
{ std::_Destroy(__first, __last); }
|
||||
|
||||
|
||||
// Names from stl_raw_storage_iter.h
|
||||
using std::raw_storage_iterator;
|
||||
|
||||
#endif /* _CPP_BACKWARD_ITERATOR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
70
TBE/MinGW/include/c++/3.2.3/backward/list.h
Normal file
70
TBE/MinGW/include/c++/3.2.3/backward/list.h
Normal file
@@ -0,0 +1,70 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_LIST_H
|
||||
#define _CPP_BACKWARD_LIST_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include "alloc.h"
|
||||
#include <list>
|
||||
|
||||
using std::list;
|
||||
|
||||
#endif /* _CPP_BACKWARD_LIST_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/map.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/map.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_MAP_H
|
||||
#define _CPP_BACKWARD_MAP_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "tree.h"
|
||||
#include <map>
|
||||
|
||||
using std::map;
|
||||
|
||||
#endif /* _CPP_BACKWARD_MAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/multimap.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/multimap.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_MULTIMAP_H
|
||||
#define _CPP_BACKWARD_MULTIMAP_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "tree.h"
|
||||
#include <map>
|
||||
|
||||
using std::multimap;
|
||||
|
||||
#endif /* _CPP_BACKWARD_MULTIMAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/multiset.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/multiset.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_MULTISET_H
|
||||
#define _CPP_BACKWARD_MULTISET_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "tree.h"
|
||||
#include <set>
|
||||
|
||||
using std::multiset;
|
||||
|
||||
#endif /* _CPP_BACKWARD_MULTISET_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
42
TBE/MinGW/include/c++/3.2.3/backward/new.h
Normal file
42
TBE/MinGW/include/c++/3.2.3/backward/new.h
Normal file
@@ -0,0 +1,42 @@
|
||||
// -*- C++ -*- forwarding header.
|
||||
// Copyright (C) 2000 Free Software Foundation
|
||||
|
||||
// This file is part of GNU CC.
|
||||
//
|
||||
// GNU CC is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// GNU CC is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with GNU CC; see the file COPYING. If not, write to
|
||||
// the Free Software Foundation, 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_NEW_H
|
||||
#define _CPP_BACKWARD_NEW_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <new>
|
||||
|
||||
using std::bad_alloc;
|
||||
using std::nothrow_t;
|
||||
using std::nothrow;
|
||||
using std::new_handler;
|
||||
using std::set_new_handler;
|
||||
|
||||
#endif
|
||||
38
TBE/MinGW/include/c++/3.2.3/backward/ostream.h
Normal file
38
TBE/MinGW/include/c++/3.2.3/backward/ostream.h
Normal file
@@ -0,0 +1,38 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_OSTREAM_H
|
||||
#define _CPP_BACKWARD_OSTREAM_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "iostream.h"
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
70
TBE/MinGW/include/c++/3.2.3/backward/pair.h
Normal file
70
TBE/MinGW/include/c++/3.2.3/backward/pair.h
Normal file
@@ -0,0 +1,70 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_PAIR_H
|
||||
#define _CPP_BACKWARD_PAIR_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <bits/c++config.h>
|
||||
#include <bits/stl_pair.h>
|
||||
|
||||
using std::pair;
|
||||
using std::make_pair;
|
||||
|
||||
#endif /* _CPP_BACKWARD_PAIR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
41
TBE/MinGW/include/c++/3.2.3/backward/queue.h
Normal file
41
TBE/MinGW/include/c++/3.2.3/backward/queue.h
Normal file
@@ -0,0 +1,41 @@
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_QUEUE_H
|
||||
#define _CPP_BACKWARD_QUEUE_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <queue>
|
||||
|
||||
using std::queue;
|
||||
using std::priority_queue;
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
60
TBE/MinGW/include/c++/3.2.3/backward/rope.h
Normal file
60
TBE/MinGW/include/c++/3.2.3/backward/rope.h
Normal file
@@ -0,0 +1,60 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_ROPE_H
|
||||
#define _CPP_BACKWARD_ROPE_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "hashtable.h"
|
||||
#include <ext/rope>
|
||||
|
||||
using __gnu_cxx::char_producer;
|
||||
using __gnu_cxx::sequence_buffer;
|
||||
using __gnu_cxx::rope;
|
||||
using __gnu_cxx::crope;
|
||||
using __gnu_cxx::wrope;
|
||||
|
||||
#endif /* _CPP_BACKWARD_ROPE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
69
TBE/MinGW/include/c++/3.2.3/backward/set.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/backward/set.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_SET_H
|
||||
#define _CPP_BACKWARD_SET_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "tree.h"
|
||||
#include <set>
|
||||
|
||||
using std::set;
|
||||
|
||||
#endif /* _CPP_BACKWARD_SET_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
56
TBE/MinGW/include/c++/3.2.3/backward/slist.h
Normal file
56
TBE/MinGW/include/c++/3.2.3/backward/slist.h
Normal file
@@ -0,0 +1,56 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_SLIST_H
|
||||
#define _CPP_BACKWARD_SLIST_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <ext/slist>
|
||||
|
||||
using __gnu_cxx::slist;
|
||||
|
||||
#endif /* _CPP_BACKWARD_SLIST_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
72
TBE/MinGW/include/c++/3.2.3/backward/stack.h
Normal file
72
TBE/MinGW/include/c++/3.2.3/backward/stack.h
Normal file
@@ -0,0 +1,72 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_STACK_H
|
||||
#define _CPP_BACKWARD_STACK_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "vector.h"
|
||||
#include "deque.h"
|
||||
#include "heap.h"
|
||||
#include "queue.h"
|
||||
#include <stack>
|
||||
|
||||
using std::stack;
|
||||
|
||||
#endif /* _CPP_BACKWARD_STACK_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
38
TBE/MinGW/include/c++/3.2.3/backward/stream.h
Normal file
38
TBE/MinGW/include/c++/3.2.3/backward/stream.h
Normal file
@@ -0,0 +1,38 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_STREAM_H
|
||||
#define _CPP_BACKWARD_STREAM_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "iostream.h"
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
40
TBE/MinGW/include/c++/3.2.3/backward/streambuf.h
Normal file
40
TBE/MinGW/include/c++/3.2.3/backward/streambuf.h
Normal file
@@ -0,0 +1,40 @@
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_STREAMBUF_H
|
||||
#define _CPP_BACKWARD_STREAMBUF_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <streambuf>
|
||||
|
||||
using std::streambuf;
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
174
TBE/MinGW/include/c++/3.2.3/backward/strstream
Normal file
174
TBE/MinGW/include/c++/3.2.3/backward/strstream
Normal file
@@ -0,0 +1,174 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
// WARNING: The classes defined in this header are DEPRECATED. This
|
||||
// header is defined in section D.7.1 of the C++ standard, and it
|
||||
// MAY BE REMOVED in a future standard revision. You should use the
|
||||
// header <sstream> instead.
|
||||
|
||||
#ifndef __SGI_STL_STRSTREAM
|
||||
#define __SGI_STL_STRSTREAM
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <iosfwd>
|
||||
#include <ios>
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#include <string>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Class strstreambuf, a streambuf class that manages an array of char.
|
||||
// Note that this class is not a template.
|
||||
class strstreambuf : public basic_streambuf<char, char_traits<char> >
|
||||
{
|
||||
public:
|
||||
// Types.
|
||||
typedef char_traits<char> _Traits;
|
||||
typedef basic_streambuf<char, _Traits> _Base;
|
||||
|
||||
public:
|
||||
// Constructor, destructor
|
||||
explicit strstreambuf(streamsize __initial_capacity = 0);
|
||||
strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*));
|
||||
|
||||
strstreambuf(char* __get, streamsize __n, char* __put = 0);
|
||||
strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0);
|
||||
strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0);
|
||||
|
||||
strstreambuf(const char* __get, streamsize __n);
|
||||
strstreambuf(const signed char* __get, streamsize __n);
|
||||
strstreambuf(const unsigned char* __get, streamsize __n);
|
||||
|
||||
virtual ~strstreambuf();
|
||||
|
||||
public:
|
||||
void freeze(bool = true);
|
||||
char* str();
|
||||
int pcount() const;
|
||||
|
||||
protected:
|
||||
virtual int_type overflow(int_type __c = _Traits::eof());
|
||||
virtual int_type pbackfail(int_type __c = _Traits::eof());
|
||||
virtual int_type underflow();
|
||||
virtual _Base* setbuf(char* __buf, streamsize __n);
|
||||
virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
|
||||
ios_base::openmode __mode
|
||||
= ios_base::in | ios_base::out);
|
||||
virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
|
||||
= ios_base::in | ios_base::out);
|
||||
|
||||
private:
|
||||
// Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun.
|
||||
char* _M_alloc(size_t);
|
||||
void _M_free(char*);
|
||||
|
||||
// Helper function used in constructors.
|
||||
void _M_setup(char* __get, char* __put, streamsize __n);
|
||||
|
||||
private:
|
||||
// Data members.
|
||||
void* (*_M_alloc_fun)(size_t);
|
||||
void (*_M_free_fun)(void*);
|
||||
|
||||
bool _M_dynamic : 1;
|
||||
bool _M_frozen : 1;
|
||||
bool _M_constant : 1;
|
||||
};
|
||||
|
||||
// Class istrstream, an istream that manages a strstreambuf.
|
||||
class istrstream : public basic_istream<char>
|
||||
{
|
||||
public:
|
||||
explicit istrstream(char*);
|
||||
explicit istrstream(const char*);
|
||||
istrstream(char* , streamsize);
|
||||
istrstream(const char*, streamsize);
|
||||
virtual ~istrstream();
|
||||
|
||||
strstreambuf* rdbuf() const;
|
||||
char* str();
|
||||
|
||||
private:
|
||||
strstreambuf _M_buf;
|
||||
};
|
||||
|
||||
// Class ostrstream
|
||||
class ostrstream : public basic_ostream<char>
|
||||
{
|
||||
public:
|
||||
ostrstream();
|
||||
ostrstream(char*, int, ios_base::openmode = ios_base::out);
|
||||
virtual ~ostrstream();
|
||||
|
||||
strstreambuf* rdbuf() const;
|
||||
void freeze(bool = true);
|
||||
char* str();
|
||||
int pcount() const;
|
||||
|
||||
private:
|
||||
strstreambuf _M_buf;
|
||||
};
|
||||
|
||||
// Class strstream
|
||||
class strstream : public basic_iostream<char>
|
||||
{
|
||||
public:
|
||||
typedef char char_type;
|
||||
typedef char_traits<char>::int_type int_type;
|
||||
typedef char_traits<char>::pos_type pos_type;
|
||||
typedef char_traits<char>::off_type off_type;
|
||||
|
||||
strstream();
|
||||
strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out);
|
||||
virtual ~strstream();
|
||||
|
||||
strstreambuf* rdbuf() const;
|
||||
void freeze(bool = true);
|
||||
int pcount() const;
|
||||
char* str();
|
||||
|
||||
private:
|
||||
strstreambuf _M_buf;
|
||||
};
|
||||
} // namespace std
|
||||
#endif
|
||||
41
TBE/MinGW/include/c++/3.2.3/backward/strstream.h
Normal file
41
TBE/MinGW/include/c++/3.2.3/backward/strstream.h
Normal file
@@ -0,0 +1,41 @@
|
||||
// -*- C++ -*- forwarding header.
|
||||
// Copyright (C) 2000 Free Software Foundation
|
||||
|
||||
// This file is part of GNU CC.
|
||||
//
|
||||
// GNU CC is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// GNU CC is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with GNU CC; see the file COPYING. If not, write to
|
||||
// the Free Software Foundation, 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BACKWARD_STRSTREAM_H
|
||||
#define _CPP_BACKWARD_STRSTREAM_H 1
|
||||
|
||||
#include "strstream"
|
||||
|
||||
using std::strstreambuf;
|
||||
using std::istrstream;
|
||||
using std::ostrstream;
|
||||
using std::strstream;
|
||||
|
||||
#endif
|
||||
|
||||
78
TBE/MinGW/include/c++/3.2.3/backward/tempbuf.h
Normal file
78
TBE/MinGW/include/c++/3.2.3/backward/tempbuf.h
Normal file
@@ -0,0 +1,78 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_TEMPBUF_H
|
||||
#define _CPP_BACKWARD_TEMPBUF_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "pair.h"
|
||||
#include "iterator.h"
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <bits/type_traits.h>
|
||||
#include <bits/stl_construct.h>
|
||||
#include <bits/stl_uninitialized.h>
|
||||
#include <ext/memory>
|
||||
|
||||
using std::get_temporary_buffer;
|
||||
using std::return_temporary_buffer;
|
||||
using __gnu_cxx::temporary_buffer;
|
||||
|
||||
#endif /* _CPP_BACKWARD_TEMPBUF_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
55
TBE/MinGW/include/c++/3.2.3/backward/tree.h
Normal file
55
TBE/MinGW/include/c++/3.2.3/backward/tree.h
Normal file
@@ -0,0 +1,55 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _CPP_EXT_TREE
|
||||
#define _CPP_EXT_TREE 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include <ext/rb_tree>
|
||||
|
||||
using __gnu_cxx::rb_tree;
|
||||
|
||||
#endif
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
70
TBE/MinGW/include/c++/3.2.3/backward/vector.h
Normal file
70
TBE/MinGW/include/c++/3.2.3/backward/vector.h
Normal file
@@ -0,0 +1,70 @@
|
||||
// Backward-compat support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BACKWARD_VECTOR_H
|
||||
#define _CPP_BACKWARD_VECTOR_H 1
|
||||
|
||||
#include "backward_warning.h"
|
||||
#include "algobase.h"
|
||||
#include "alloc.h"
|
||||
#include <vector>
|
||||
|
||||
using std::vector;
|
||||
|
||||
#endif /* _CPP_BACKWARD_VECTOR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
210
TBE/MinGW/include/c++/3.2.3/bits/basic_ios.h
Normal file
210
TBE/MinGW/include/c++/3.2.3/bits/basic_ios.h
Normal file
@@ -0,0 +1,210 @@
|
||||
// Iostreams base classes -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/** @file basic_ios.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_BASICIOS_H
|
||||
#define _CPP_BITS_BASICIOS_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/streambuf_iterator.h>
|
||||
#include <bits/locale_facets.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 27.4.5 Template class basic_ios
|
||||
template<typename _CharT, typename _Traits>
|
||||
class basic_ios : public ios_base
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef _CharT char_type;
|
||||
typedef typename _Traits::int_type int_type;
|
||||
typedef typename _Traits::pos_type pos_type;
|
||||
typedef typename _Traits::off_type off_type;
|
||||
typedef _Traits traits_type;
|
||||
|
||||
// Non-standard Types:
|
||||
typedef ctype<_CharT> __ctype_type;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter;
|
||||
typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
|
||||
typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter;
|
||||
typedef num_get<_CharT, __istreambuf_iter> __numget_type;
|
||||
|
||||
// Data members:
|
||||
protected:
|
||||
basic_ostream<_CharT, _Traits>* _M_tie;
|
||||
mutable char_type _M_fill;
|
||||
mutable bool _M_fill_init;
|
||||
basic_streambuf<_CharT, _Traits>* _M_streambuf;
|
||||
|
||||
// Cached use_facet<ctype>, which is based on the current locale info.
|
||||
const __ctype_type* _M_fctype;
|
||||
// From ostream.
|
||||
const __numput_type* _M_fnumput;
|
||||
// From istream.
|
||||
const __numget_type* _M_fnumget;
|
||||
|
||||
public:
|
||||
operator void*() const
|
||||
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
|
||||
|
||||
bool
|
||||
operator!() const
|
||||
{ return this->fail(); }
|
||||
|
||||
iostate
|
||||
rdstate() const
|
||||
{ return _M_streambuf_state; }
|
||||
|
||||
void
|
||||
clear(iostate __state = goodbit);
|
||||
|
||||
void
|
||||
setstate(iostate __state)
|
||||
{ this->clear(this->rdstate() | __state); }
|
||||
|
||||
bool
|
||||
good() const
|
||||
{ return this->rdstate() == 0; }
|
||||
|
||||
bool
|
||||
eof() const
|
||||
{ return (this->rdstate() & eofbit) != 0; }
|
||||
|
||||
bool
|
||||
fail() const
|
||||
{ return (this->rdstate() & (badbit | failbit)) != 0; }
|
||||
|
||||
bool
|
||||
bad() const
|
||||
{ return (this->rdstate() & badbit) != 0; }
|
||||
|
||||
iostate
|
||||
exceptions() const
|
||||
{ return _M_exception; }
|
||||
|
||||
void
|
||||
exceptions(iostate __except)
|
||||
{
|
||||
_M_exception = __except;
|
||||
this->clear(_M_streambuf_state);
|
||||
}
|
||||
|
||||
// Constructor/destructor:
|
||||
explicit
|
||||
basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base()
|
||||
{ this->init(__sb); }
|
||||
|
||||
virtual
|
||||
~basic_ios() { }
|
||||
|
||||
// Members:
|
||||
basic_ostream<_CharT, _Traits>*
|
||||
tie() const
|
||||
{ return _M_tie; }
|
||||
|
||||
basic_ostream<_CharT, _Traits>*
|
||||
tie(basic_ostream<_CharT, _Traits>* __tiestr)
|
||||
{
|
||||
basic_ostream<_CharT, _Traits>* __old = _M_tie;
|
||||
_M_tie = __tiestr;
|
||||
return __old;
|
||||
}
|
||||
|
||||
basic_streambuf<_CharT, _Traits>*
|
||||
rdbuf() const
|
||||
{ return _M_streambuf; }
|
||||
|
||||
basic_streambuf<_CharT, _Traits>*
|
||||
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
|
||||
|
||||
basic_ios&
|
||||
copyfmt(const basic_ios& __rhs);
|
||||
|
||||
char_type
|
||||
fill() const
|
||||
{
|
||||
if (!_M_fill_init)
|
||||
{
|
||||
_M_fill = this->widen(' ');
|
||||
_M_fill_init = true;
|
||||
}
|
||||
return _M_fill;
|
||||
}
|
||||
|
||||
char_type
|
||||
fill(char_type __ch)
|
||||
{
|
||||
char_type __old = this->fill();
|
||||
_M_fill = __ch;
|
||||
return __old;
|
||||
}
|
||||
|
||||
// Locales:
|
||||
locale
|
||||
imbue(const locale& __loc);
|
||||
|
||||
char
|
||||
narrow(char_type __c, char __dfault) const;
|
||||
|
||||
char_type
|
||||
widen(char __c) const;
|
||||
|
||||
protected:
|
||||
// 27.4.5.1 basic_ios constructors
|
||||
basic_ios() : ios_base()
|
||||
{ }
|
||||
|
||||
void
|
||||
init(basic_streambuf<_CharT, _Traits>* __sb);
|
||||
|
||||
bool
|
||||
_M_check_facet(const locale::facet* __f) const
|
||||
{
|
||||
if (!__f)
|
||||
__throw_bad_cast();
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
_M_cache_facets(const locale& __loc);
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
|
||||
# define export
|
||||
#include <bits/basic_ios.tcc>
|
||||
#endif
|
||||
|
||||
#endif /* _CPP_BITS_BASICIOS_H */
|
||||
196
TBE/MinGW/include/c++/3.2.3/bits/basic_ios.tcc
Normal file
196
TBE/MinGW/include/c++/3.2.3/bits/basic_ios.tcc
Normal file
@@ -0,0 +1,196 @@
|
||||
// basic_ios locale and locale-related member functions -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1999, 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
#ifndef _CPP_BITS_BASICIOS_TCC
|
||||
#define _CPP_BITS_BASICIOS_TCC 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_ios<_CharT, _Traits>::clear(iostate __state)
|
||||
{
|
||||
if (this->rdbuf())
|
||||
_M_streambuf_state = __state;
|
||||
else
|
||||
_M_streambuf_state = __state | badbit;
|
||||
if ((this->rdstate() & this->exceptions()))
|
||||
__throw_ios_failure("basic_ios::clear(iostate) caused exception");
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_streambuf<_CharT, _Traits>*
|
||||
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
|
||||
{
|
||||
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
|
||||
_M_streambuf = __sb;
|
||||
this->clear();
|
||||
return __old;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ios<_CharT, _Traits>&
|
||||
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
|
||||
{
|
||||
// Per 27.1.1.1, do not call imbue, yet must trash all caches
|
||||
// associated with imbue()
|
||||
|
||||
// Alloc any new word array first, so if it fails we have "rollback".
|
||||
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
|
||||
_M_local_word : new _Words[__rhs._M_word_size];
|
||||
|
||||
// Bump refs before doing callbacks, for safety.
|
||||
_Callback_list* __cb = __rhs._M_callbacks;
|
||||
if (__cb)
|
||||
__cb->_M_add_reference();
|
||||
_M_call_callbacks(erase_event);
|
||||
if (_M_word != _M_local_word)
|
||||
{
|
||||
delete [] _M_word;
|
||||
_M_word = 0;
|
||||
}
|
||||
_M_dispose_callbacks();
|
||||
|
||||
_M_callbacks = __cb; // NB: Don't want any added during above.
|
||||
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
|
||||
__words[__i] = __rhs._M_word[__i];
|
||||
if (_M_word != _M_local_word)
|
||||
{
|
||||
delete [] _M_word;
|
||||
_M_word = 0;
|
||||
}
|
||||
_M_word = __words;
|
||||
_M_word_size = __rhs._M_word_size;
|
||||
|
||||
this->flags(__rhs.flags());
|
||||
this->width(__rhs.width());
|
||||
this->precision(__rhs.precision());
|
||||
this->tie(__rhs.tie());
|
||||
this->fill(__rhs.fill());
|
||||
// The next is required to be the last assignment.
|
||||
this->exceptions(__rhs.exceptions());
|
||||
|
||||
_M_call_callbacks(copyfmt_event);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
char
|
||||
basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
|
||||
{
|
||||
char __ret = __dfault;
|
||||
if (_M_check_facet(_M_fctype))
|
||||
__ret = _M_fctype->narrow(__c, __dfault);
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
_CharT
|
||||
basic_ios<_CharT, _Traits>::widen(char __c) const
|
||||
{
|
||||
char_type __ret = char_type();
|
||||
if (_M_check_facet(_M_fctype))
|
||||
__ret = _M_fctype->widen(__c);
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Locales:
|
||||
template<typename _CharT, typename _Traits>
|
||||
locale
|
||||
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
|
||||
{
|
||||
locale __old(this->getloc());
|
||||
ios_base::imbue(__loc);
|
||||
_M_cache_facets(__loc);
|
||||
if (this->rdbuf() != 0)
|
||||
this->rdbuf()->pubimbue(__loc);
|
||||
return __old;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
|
||||
{
|
||||
// NB: This may be called more than once on the same object.
|
||||
ios_base::_M_init();
|
||||
_M_cache_facets(_M_ios_locale);
|
||||
_M_tie = 0;
|
||||
|
||||
// NB: The 27.4.4.1 Postconditions Table specifies requirements
|
||||
// after basic_ios::init() has been called. As part of this,
|
||||
// fill() must return widen(' ') any time after init() has been
|
||||
// called, which needs an imbued ctype facet of char_type to
|
||||
// return without throwing an exception. Unfortunately,
|
||||
// ctype<char_type> is not necessarily a required facet, so
|
||||
// streams with char_type != [char, wchar_t] will not have it by
|
||||
// default. Because of this, the correct value for _M_fill is
|
||||
// constructed on the first call of fill(). That way,
|
||||
// unformatted input and output with non-required basic_ios
|
||||
// instantiations is possible even without imbuing the expected
|
||||
// ctype<char_type> facet.
|
||||
_M_fill = _CharT();
|
||||
_M_fill_init = false;
|
||||
|
||||
_M_exception = goodbit;
|
||||
_M_streambuf = __sb;
|
||||
_M_streambuf_state = __sb ? goodbit : badbit;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_ios<_CharT, _Traits>::_M_cache_facets(const locale& __loc)
|
||||
{
|
||||
if (has_facet<__ctype_type>(__loc))
|
||||
_M_fctype = &use_facet<__ctype_type>(__loc);
|
||||
else
|
||||
_M_fctype = 0;
|
||||
// Should be filled in by ostream and istream, respectively.
|
||||
if (has_facet<__numput_type>(__loc))
|
||||
_M_fnumput = &use_facet<__numput_type>(__loc);
|
||||
else
|
||||
_M_fnumput = 0;
|
||||
if (has_facet<__numget_type>(__loc))
|
||||
_M_fnumget = &use_facet<__numget_type>(__loc);
|
||||
else
|
||||
_M_fnumget = 0;
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_ios<char>;
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_ios<wchar_t>;
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
1111
TBE/MinGW/include/c++/3.2.3/bits/basic_string.h
Normal file
1111
TBE/MinGW/include/c++/3.2.3/bits/basic_string.h
Normal file
File diff suppressed because it is too large
Load Diff
979
TBE/MinGW/include/c++/3.2.3/bits/basic_string.tcc
Normal file
979
TBE/MinGW/include/c++/3.2.3/bits/basic_string.tcc
Normal file
@@ -0,0 +1,979 @@
|
||||
// Components for manipulating sequences of characters -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 21 Strings library
|
||||
//
|
||||
|
||||
// This file is included by <string>. It is not meant to be included
|
||||
// separately.
|
||||
|
||||
// Written by Jason Merrill based upon the specification by Takanori Adachi
|
||||
// in ANSI X3J16/94-0013R2. Rewritten by Nathan Myers to ISO-14882.
|
||||
|
||||
#ifndef _CPP_BITS_STRING_TCC
|
||||
#define _CPP_BITS_STRING_TCC 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_Rep::_S_max_size = (((npos - sizeof(_Rep))/sizeof(_CharT)) - 1) / 4;
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
const _CharT
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_Rep::_S_terminal = _CharT();
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::npos;
|
||||
|
||||
// Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
|
||||
// at static init time (before static ctors are run).
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep_storage[
|
||||
(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];
|
||||
|
||||
// NB: This is the special case for Input Iterators, used in
|
||||
// istreambuf_iterators, etc.
|
||||
// Input Iterators have a cost structure very different from
|
||||
// pointers, calling for a different coding style.
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
template<typename _InIter>
|
||||
_CharT*
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
|
||||
input_iterator_tag)
|
||||
{
|
||||
if (__beg == __end && __a == _Alloc())
|
||||
return _S_empty_rep()._M_refcopy();
|
||||
// Avoid reallocation for common case.
|
||||
_CharT __buf[100];
|
||||
size_type __i = 0;
|
||||
while (__beg != __end && __i < sizeof(__buf) / sizeof(_CharT))
|
||||
{
|
||||
__buf[__i++] = *__beg;
|
||||
++__beg;
|
||||
}
|
||||
_Rep* __r = _Rep::_S_create(__i, __a);
|
||||
traits_type::copy(__r->_M_refdata(), __buf, __i);
|
||||
__r->_M_length = __i;
|
||||
try
|
||||
{
|
||||
// NB: this loop looks precisely this way because
|
||||
// it avoids comparing __beg != __end any more
|
||||
// than strictly necessary; != might be expensive!
|
||||
for (;;)
|
||||
{
|
||||
_CharT* __p = __r->_M_refdata() + __r->_M_length;
|
||||
_CharT* __last = __r->_M_refdata() + __r->_M_capacity;
|
||||
for (;;)
|
||||
{
|
||||
if (__beg == __end)
|
||||
{
|
||||
__r->_M_length = __p - __r->_M_refdata();
|
||||
*__p = _Rep::_S_terminal; // grrr.
|
||||
return __r->_M_refdata();
|
||||
}
|
||||
if (__p == __last)
|
||||
break;
|
||||
*__p++ = *__beg;
|
||||
++__beg;
|
||||
}
|
||||
// Allocate more space.
|
||||
size_type __len = __p - __r->_M_refdata();
|
||||
_Rep* __another = _Rep::_S_create(__len + 1, __a);
|
||||
traits_type::copy(__another->_M_refdata(),
|
||||
__r->_M_refdata(), __len);
|
||||
__r->_M_destroy(__a);
|
||||
__r = __another;
|
||||
__r->_M_length = __len;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
__r->_M_destroy(__a);
|
||||
__throw_exception_again;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
template <class _InIter>
|
||||
_CharT*
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
|
||||
forward_iterator_tag)
|
||||
{
|
||||
size_type __dnew = static_cast<size_type>(distance(__beg, __end));
|
||||
|
||||
if (__beg == __end && __a == _Alloc())
|
||||
return _S_empty_rep()._M_refcopy();
|
||||
|
||||
// NB: Not required, but considered best practice.
|
||||
if (__builtin_expect(__beg == _InIter(), 0))
|
||||
__throw_logic_error("attempt to create string with null pointer");
|
||||
|
||||
// Check for out_of_range and length_error exceptions.
|
||||
_Rep* __r = _Rep::_S_create(__dnew, __a);
|
||||
try
|
||||
{ _S_copy_chars(__r->_M_refdata(), __beg, __end); }
|
||||
catch(...)
|
||||
{
|
||||
__r->_M_destroy(__a);
|
||||
__throw_exception_again;
|
||||
}
|
||||
__r->_M_length = __dnew;
|
||||
|
||||
__r->_M_refdata()[__dnew] = _Rep::_S_terminal; // grrr.
|
||||
return __r->_M_refdata();
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
_CharT*
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_S_construct(size_type __n, _CharT __c, const _Alloc& __a)
|
||||
{
|
||||
if (__n == 0 && __a == _Alloc())
|
||||
return _S_empty_rep()._M_refcopy();
|
||||
|
||||
// Check for out_of_range and length_error exceptions.
|
||||
_Rep* __r = _Rep::_S_create(__n, __a);
|
||||
try
|
||||
{
|
||||
if (__n)
|
||||
traits_type::assign(__r->_M_refdata(), __n, __c);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
__r->_M_destroy(__a);
|
||||
__throw_exception_again;
|
||||
}
|
||||
__r->_M_length = __n;
|
||||
__r->_M_refdata()[__n] = _Rep::_S_terminal; // grrr
|
||||
return __r->_M_refdata();
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const basic_string& __str)
|
||||
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(), __str.get_allocator()),
|
||||
__str.get_allocator())
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const basic_string& __str, size_type __pos, size_type __n)
|
||||
: _M_dataplus(_S_construct(__str._M_check(__pos),
|
||||
__str._M_fold(__pos, __n), _Alloc()), _Alloc())
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const basic_string& __str, size_type __pos,
|
||||
size_type __n, const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(__str._M_check(__pos),
|
||||
__str._M_fold(__pos, __n), __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(const _CharT* __s, const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
|
||||
__s + npos, __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(size_type __n, _CharT __c, const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(__n, __c, __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
template<typename _InputIter>
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a)
|
||||
: _M_dataplus(_S_construct(__beg, __end, __a), __a)
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::assign(const basic_string& __str)
|
||||
{
|
||||
if (_M_rep() != __str._M_rep())
|
||||
{
|
||||
// XXX MT
|
||||
allocator_type __a = this->get_allocator();
|
||||
_CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
|
||||
_M_rep()->_M_dispose(__a);
|
||||
_M_data(__tmp);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
||||
_M_destroy(const _Alloc& __a) throw ()
|
||||
{
|
||||
size_type __size = sizeof(_Rep) + (_M_capacity + 1) * sizeof(_CharT);
|
||||
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard()
|
||||
{
|
||||
if (_M_rep()->_M_is_shared())
|
||||
_M_mutate(0, 0, 0);
|
||||
_M_rep()->_M_set_leaked();
|
||||
}
|
||||
|
||||
// _M_mutate and, below, _M_clone, include, in the same form, an exponential
|
||||
// growth policy, necessary to meet amortized linear time requirements of
|
||||
// the library: see http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
|
||||
// The policy is active for allocations requiring an amount of memory above
|
||||
// system pagesize. This is consistent with the requirements of the standard:
|
||||
// see, f.i., http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_M_mutate(size_type __pos, size_type __len1, size_type __len2)
|
||||
{
|
||||
size_type __old_size = this->size();
|
||||
const size_type __new_size = __old_size + __len2 - __len1;
|
||||
const _CharT* __src = _M_data() + __pos + __len1;
|
||||
const size_type __how_much = __old_size - __pos - __len1;
|
||||
|
||||
if (_M_rep()->_M_is_shared() || __new_size > capacity())
|
||||
{
|
||||
// Must reallocate.
|
||||
allocator_type __a = get_allocator();
|
||||
// See below (_S_create) for the meaning and value of these
|
||||
// constants.
|
||||
const size_type __pagesize = 4096;
|
||||
const size_type __malloc_header_size = 4 * sizeof (void*);
|
||||
// The biggest string which fits in a memory page
|
||||
const size_type __page_capacity = (__pagesize - __malloc_header_size
|
||||
- sizeof(_Rep) - sizeof(_CharT))
|
||||
/ sizeof(_CharT);
|
||||
_Rep* __r;
|
||||
if (__new_size > capacity() && __new_size > __page_capacity)
|
||||
// Growing exponentially.
|
||||
__r = _Rep::_S_create(__new_size > 2*capacity() ?
|
||||
__new_size : 2*capacity(), __a);
|
||||
else
|
||||
__r = _Rep::_S_create(__new_size, __a);
|
||||
try
|
||||
{
|
||||
if (__pos)
|
||||
traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
|
||||
if (__how_much)
|
||||
traits_type::copy(__r->_M_refdata() + __pos + __len2,
|
||||
__src, __how_much);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
__r->_M_dispose(get_allocator());
|
||||
__throw_exception_again;
|
||||
}
|
||||
_M_rep()->_M_dispose(__a);
|
||||
_M_data(__r->_M_refdata());
|
||||
}
|
||||
else if (__how_much && __len1 != __len2)
|
||||
{
|
||||
// Work in-place
|
||||
traits_type::move(_M_data() + __pos + __len2, __src, __how_much);
|
||||
}
|
||||
_M_rep()->_M_set_sharable();
|
||||
_M_rep()->_M_length = __new_size;
|
||||
_M_data()[__new_size] = _Rep::_S_terminal; // grrr. (per 21.3.4)
|
||||
// You cannot leave those LWG people alone for a second.
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res)
|
||||
{
|
||||
if (__res > this->capacity() || _M_rep()->_M_is_shared())
|
||||
{
|
||||
if (__res > this->max_size())
|
||||
__throw_length_error("basic_string::reserve");
|
||||
// Make sure we don't shrink below the current size
|
||||
if (__res < this->size())
|
||||
__res = this->size();
|
||||
allocator_type __a = get_allocator();
|
||||
_CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
|
||||
_M_rep()->_M_dispose(__a);
|
||||
_M_data(__tmp);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s)
|
||||
{
|
||||
if (_M_rep()->_M_is_leaked())
|
||||
_M_rep()->_M_set_sharable();
|
||||
if (__s._M_rep()->_M_is_leaked())
|
||||
__s._M_rep()->_M_set_sharable();
|
||||
if (this->get_allocator() == __s.get_allocator())
|
||||
{
|
||||
_CharT* __tmp = _M_data();
|
||||
_M_data(__s._M_data());
|
||||
__s._M_data(__tmp);
|
||||
}
|
||||
// The code below can usually be optimized away.
|
||||
else
|
||||
{
|
||||
basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator());
|
||||
basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
|
||||
this->get_allocator());
|
||||
*this = __tmp2;
|
||||
__s = __tmp1;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
|
||||
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
||||
_S_create(size_t __capacity, const _Alloc& __alloc)
|
||||
{
|
||||
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 83. String::npos vs. string::max_size()
|
||||
if (__capacity > _S_max_size)
|
||||
#else
|
||||
if (__capacity == npos)
|
||||
#endif
|
||||
__throw_length_error("basic_string::_S_create");
|
||||
|
||||
// NB: Need an array of char_type[__capacity], plus a
|
||||
// terminating null char_type() element, plus enough for the
|
||||
// _Rep data structure. Whew. Seemingly so needy, yet so elemental.
|
||||
size_t __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
|
||||
|
||||
// The standard places no restriction on allocating more memory
|
||||
// than is strictly needed within this layer at the moment or as
|
||||
// requested by an explicit application call to reserve(). Many
|
||||
// malloc implementations perform quite poorly when an
|
||||
// application attempts to allocate memory in a stepwise fashion
|
||||
// growing each allocation size by only 1 char. Additionally,
|
||||
// it makes little sense to allocate less linear memory than the
|
||||
// natural blocking size of the malloc implementation.
|
||||
// Unfortunately, we would need a somewhat low-level calculation
|
||||
// with tuned parameters to get this perfect for any particular
|
||||
// malloc implementation. Fortunately, generalizations about
|
||||
// common features seen among implementations seems to suffice.
|
||||
|
||||
// __pagesize need not match the actual VM page size for good
|
||||
// results in practice, thus we pick a common value on the low
|
||||
// side. __malloc_header_size is an estimate of the amount of
|
||||
// overhead per memory allocation (in practice seen N * sizeof
|
||||
// (void*) where N is 0, 2 or 4). According to folklore,
|
||||
// picking this value on the high side is better than
|
||||
// low-balling it (especially when this algorithm is used with
|
||||
// malloc implementations that allocate memory blocks rounded up
|
||||
// to a size which is a power of 2).
|
||||
const size_t __pagesize = 4096; // must be 2^i * __subpagesize
|
||||
const size_t __subpagesize = 128; // should be >> __malloc_header_size
|
||||
const size_t __malloc_header_size = 4 * sizeof (void*);
|
||||
if ((__size + __malloc_header_size) > __pagesize)
|
||||
{
|
||||
size_t __extra =
|
||||
(__pagesize - ((__size + __malloc_header_size) % __pagesize))
|
||||
% __pagesize;
|
||||
__capacity += __extra / sizeof(_CharT);
|
||||
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
|
||||
}
|
||||
else if (__size > __subpagesize)
|
||||
{
|
||||
size_t __extra =
|
||||
(__subpagesize - ((__size + __malloc_header_size) % __subpagesize))
|
||||
% __subpagesize;
|
||||
__capacity += __extra / sizeof(_CharT);
|
||||
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
|
||||
}
|
||||
|
||||
// NB: Might throw, but no worries about a leak, mate: _Rep()
|
||||
// does not throw.
|
||||
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
|
||||
_Rep *__p = new (__place) _Rep;
|
||||
__p->_M_capacity = __capacity;
|
||||
__p->_M_set_sharable(); // One reference.
|
||||
__p->_M_length = 0;
|
||||
return __p;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
_CharT*
|
||||
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
||||
_M_clone(const _Alloc& __alloc, size_type __res)
|
||||
{
|
||||
// Requested capacity of the clone.
|
||||
const size_type __requested_cap = _M_length + __res;
|
||||
// See above (_S_create) for the meaning and value of these constants.
|
||||
const size_type __pagesize = 4096;
|
||||
const size_type __malloc_header_size = 4 * sizeof (void*);
|
||||
// The biggest string which fits in a memory page.
|
||||
const size_type __page_capacity =
|
||||
(__pagesize - __malloc_header_size - sizeof(_Rep) - sizeof(_CharT))
|
||||
/ sizeof(_CharT);
|
||||
_Rep* __r;
|
||||
if (__requested_cap > _M_capacity && __requested_cap > __page_capacity)
|
||||
// Growing exponentially.
|
||||
__r = _Rep::_S_create(__requested_cap > 2*_M_capacity ?
|
||||
__requested_cap : 2*_M_capacity, __alloc);
|
||||
else
|
||||
__r = _Rep::_S_create(__requested_cap, __alloc);
|
||||
|
||||
if (_M_length)
|
||||
{
|
||||
try
|
||||
{ traits_type::copy(__r->_M_refdata(), _M_refdata(), _M_length); }
|
||||
catch(...)
|
||||
{
|
||||
__r->_M_destroy(__alloc);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
__r->_M_length = _M_length;
|
||||
return __r->_M_refdata();
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
|
||||
{
|
||||
if (__n > max_size())
|
||||
__throw_length_error("basic_string::resize");
|
||||
size_type __size = this->size();
|
||||
if (__size < __n)
|
||||
this->append(__n - __size, __c);
|
||||
else if (__n < __size)
|
||||
this->erase(__n);
|
||||
// else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
|
||||
}
|
||||
|
||||
// This is the general replace helper, which currently gets instantiated both
|
||||
// for input iterators and reverse iterators. It buffers internally and then
|
||||
// calls _M_replace_safe.
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
template<typename _InputIter>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_M_replace(iterator __i1, iterator __i2, _InputIter __k1,
|
||||
_InputIter __k2, input_iterator_tag)
|
||||
{
|
||||
// Save concerned source string data in a temporary.
|
||||
basic_string __s(__k1, __k2);
|
||||
return _M_replace_safe(__i1, __i2, __s._M_ibegin(), __s._M_iend());
|
||||
}
|
||||
|
||||
// This is a special replace helper, which does not buffer internally
|
||||
// and can be used in "safe" situations involving forward iterators,
|
||||
// i.e., when source and destination ranges are known to not overlap.
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
template<typename _ForwardIter>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
_M_replace_safe(iterator __i1, iterator __i2, _ForwardIter __k1,
|
||||
_ForwardIter __k2)
|
||||
{
|
||||
size_type __dnew = static_cast<size_type>(distance(__k1, __k2));
|
||||
size_type __dold = __i2 - __i1;
|
||||
size_type __dmax = this->max_size();
|
||||
|
||||
if (__dmax <= __dnew)
|
||||
__throw_length_error("basic_string::_M_replace");
|
||||
size_type __off = __i1 - _M_ibegin();
|
||||
_M_mutate(__off, __dold, __dnew);
|
||||
|
||||
// Invalidated __i1, __i2
|
||||
if (__dnew)
|
||||
_S_copy_chars(_M_data() + __off, __k1, __k2);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
replace(size_type __pos1, size_type __n1, const basic_string& __str,
|
||||
size_type __pos2, size_type __n2)
|
||||
{
|
||||
const size_type __strsize = __str.size();
|
||||
if (__pos2 > __strsize)
|
||||
__throw_out_of_range("basic_string::replace");
|
||||
const bool __testn2 = __n2 < __strsize - __pos2;
|
||||
const size_type __foldn2 = __testn2 ? __n2 : __strsize - __pos2;
|
||||
return this->replace(__pos1, __n1,
|
||||
__str._M_data() + __pos2, __foldn2);
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
append(const basic_string& __str)
|
||||
{
|
||||
// Iff appending itself, string needs to pre-reserve the
|
||||
// correct size so that _M_mutate does not clobber the
|
||||
// iterators formed here.
|
||||
size_type __size = __str.size();
|
||||
size_type __len = __size + this->size();
|
||||
if (__len > this->capacity())
|
||||
this->reserve(__len);
|
||||
return _M_replace_safe(_M_iend(), _M_iend(), __str._M_ibegin(),
|
||||
__str._M_iend());
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
append(const basic_string& __str, size_type __pos, size_type __n)
|
||||
{
|
||||
// Iff appending itself, string needs to pre-reserve the
|
||||
// correct size so that _M_mutate does not clobber the
|
||||
// iterators formed here.
|
||||
size_type __len = min(__str.size() - __pos, __n) + this->size();
|
||||
if (__len > this->capacity())
|
||||
this->reserve(__len);
|
||||
return _M_replace_safe(_M_iend(), _M_iend(), __str._M_check(__pos),
|
||||
__str._M_fold(__pos, __n));
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
append(const _CharT* __s, size_type __n)
|
||||
{
|
||||
size_type __len = __n + this->size();
|
||||
if (__len > this->capacity())
|
||||
this->reserve(__len);
|
||||
return _M_replace_safe(_M_iend(), _M_iend(), __s, __s + __n);
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
append(size_type __n, _CharT __c)
|
||||
{
|
||||
size_type __len = __n + this->size();
|
||||
if (__len > this->capacity())
|
||||
this->reserve(__len);
|
||||
return this->replace(_M_iend(), _M_iend(), __n, __c);
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>
|
||||
operator+(const _CharT* __lhs,
|
||||
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
||||
{
|
||||
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
||||
typedef typename __string_type::size_type __size_type;
|
||||
__size_type __len = _Traits::length(__lhs);
|
||||
__string_type __str;
|
||||
__str.reserve(__len + __rhs.size());
|
||||
__str.append(__lhs, __lhs + __len);
|
||||
__str.append(__rhs);
|
||||
return __str;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>
|
||||
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
||||
{
|
||||
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
||||
typedef typename __string_type::size_type __size_type;
|
||||
__string_type __str;
|
||||
__size_type __len = __rhs.size();
|
||||
__str.reserve(__len + 1);
|
||||
__str.append(__size_type(1), __lhs);
|
||||
__str.append(__rhs);
|
||||
return __str;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_string<_CharT, _Traits, _Alloc>&
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
replace(iterator __i1, iterator __i2, size_type __n2, _CharT __c)
|
||||
{
|
||||
size_type __n1 = __i2 - __i1;
|
||||
size_type __off1 = __i1 - _M_ibegin();
|
||||
if (max_size() - (this->size() - __n1) <= __n2)
|
||||
__throw_length_error("basic_string::replace");
|
||||
_M_mutate (__off1, __n1, __n2);
|
||||
// Invalidated __i1, __i2
|
||||
if (__n2)
|
||||
traits_type::assign(_M_data() + __off1, __n2, __c);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
copy(_CharT* __s, size_type __n, size_type __pos) const
|
||||
{
|
||||
if (__pos > this->size())
|
||||
__throw_out_of_range("basic_string::copy");
|
||||
|
||||
if (__n > this->size() - __pos)
|
||||
__n = this->size() - __pos;
|
||||
|
||||
traits_type::copy(__s, _M_data() + __pos, __n);
|
||||
// 21.3.5.7 par 3: do not append null. (good.)
|
||||
return __n;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
size_t __xpos = __pos;
|
||||
const _CharT* __data = _M_data();
|
||||
for (; __xpos + __n <= __size; ++__xpos)
|
||||
if (traits_type::compare(__data + __xpos, __s, __n) == 0)
|
||||
return __xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find(_CharT __c, size_type __pos) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
size_type __ret = npos;
|
||||
if (__pos < __size)
|
||||
{
|
||||
const _CharT* __data = _M_data();
|
||||
size_type __n = __size - __pos;
|
||||
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
|
||||
if (__p)
|
||||
__ret = __p - __data;
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
rfind(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__n <= __size)
|
||||
{
|
||||
__pos = std::min(__size - __n, __pos);
|
||||
const _CharT* __data = _M_data();
|
||||
do
|
||||
{
|
||||
if (traits_type::compare(__data + __pos, __s, __n) == 0)
|
||||
return __pos;
|
||||
}
|
||||
while (__pos-- > 0);
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
rfind(_CharT __c, size_type __pos) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__size)
|
||||
{
|
||||
size_t __xpos = __size - 1;
|
||||
if (__xpos > __pos)
|
||||
__xpos = __pos;
|
||||
|
||||
for (++__xpos; __xpos-- > 0; )
|
||||
if (traits_type::eq(_M_data()[__xpos], __c))
|
||||
return __xpos;
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
for (; __n && __pos < this->size(); ++__pos)
|
||||
{
|
||||
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
|
||||
if (__p)
|
||||
return __pos;
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__size && __n)
|
||||
{
|
||||
if (--__size > __pos)
|
||||
__size = __pos;
|
||||
do
|
||||
{
|
||||
if (traits_type::find(__s, __n, _M_data()[__size]))
|
||||
return __size;
|
||||
}
|
||||
while (__size-- != 0);
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
size_t __xpos = __pos;
|
||||
for (; __xpos < this->size(); ++__xpos)
|
||||
if (!traits_type::find(__s, __n, _M_data()[__xpos]))
|
||||
return __xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_first_not_of(_CharT __c, size_type __pos) const
|
||||
{
|
||||
size_t __xpos = __pos;
|
||||
for (; __xpos < this->size(); ++__xpos)
|
||||
if (!traits_type::eq(_M_data()[__xpos], __c))
|
||||
return __xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__size)
|
||||
{
|
||||
if (--__size > __pos)
|
||||
__size = __pos;
|
||||
do
|
||||
{
|
||||
if (!traits_type::find(__s, __n, _M_data()[__size]))
|
||||
return __size;
|
||||
}
|
||||
while (__size--);
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
find_last_not_of(_CharT __c, size_type __pos) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__size)
|
||||
{
|
||||
if (--__size > __pos)
|
||||
__size = __pos;
|
||||
do
|
||||
{
|
||||
if (!traits_type::eq(_M_data()[__size], __c))
|
||||
return __size;
|
||||
}
|
||||
while (__size--);
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
int
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
compare(size_type __pos, size_type __n, const basic_string& __str) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
size_type __osize = __str.size();
|
||||
if (__pos > __size)
|
||||
__throw_out_of_range("basic_string::compare");
|
||||
|
||||
size_type __rsize= min(__size - __pos, __n);
|
||||
size_type __len = min(__rsize, __osize);
|
||||
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
|
||||
if (!__r)
|
||||
__r = __rsize - __osize;
|
||||
return __r;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
int
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
compare(size_type __pos1, size_type __n1, const basic_string& __str,
|
||||
size_type __pos2, size_type __n2) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
size_type __osize = __str.size();
|
||||
if (__pos1 > __size || __pos2 > __osize)
|
||||
__throw_out_of_range("basic_string::compare");
|
||||
|
||||
size_type __rsize = min(__size - __pos1, __n1);
|
||||
size_type __rosize = min(__osize - __pos2, __n2);
|
||||
size_type __len = min(__rsize, __rosize);
|
||||
int __r = traits_type::compare(_M_data() + __pos1,
|
||||
__str.data() + __pos2, __len);
|
||||
if (!__r)
|
||||
__r = __rsize - __rosize;
|
||||
return __r;
|
||||
}
|
||||
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
int
|
||||
basic_string<_CharT, _Traits, _Alloc>::
|
||||
compare(const _CharT* __s) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
size_type __osize = traits_type::length(__s);
|
||||
size_type __len = min(__size, __osize);
|
||||
int __r = traits_type::compare(_M_data(), __s, __len);
|
||||
if (!__r)
|
||||
__r = __size - __osize;
|
||||
return __r;
|
||||
}
|
||||
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
int
|
||||
basic_string <_CharT, _Traits, _Alloc>::
|
||||
compare(size_type __pos, size_type __n1, const _CharT* __s) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__pos > __size)
|
||||
__throw_out_of_range("basic_string::compare");
|
||||
|
||||
size_type __osize = traits_type::length(__s);
|
||||
size_type __rsize = min(__size - __pos, __n1);
|
||||
size_type __len = min(__rsize, __osize);
|
||||
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
|
||||
if (!__r)
|
||||
__r = __rsize - __osize;
|
||||
return __r;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
int
|
||||
basic_string <_CharT, _Traits, _Alloc>::
|
||||
compare(size_type __pos, size_type __n1, const _CharT* __s,
|
||||
size_type __n2) const
|
||||
{
|
||||
size_type __size = this->size();
|
||||
if (__pos > __size)
|
||||
__throw_out_of_range("basic_string::compare");
|
||||
|
||||
size_type __osize = min(traits_type::length(__s), __n2);
|
||||
size_type __rsize = min(__size - __pos, __n1);
|
||||
size_type __len = min(__rsize, __osize);
|
||||
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
|
||||
if (!__r)
|
||||
__r = __rsize - __osize;
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Alloc>
|
||||
void
|
||||
_S_string_copy(const basic_string<_CharT, _Traits, _Alloc>& __str,
|
||||
_CharT* __buf, typename _Alloc::size_type __bufsiz)
|
||||
{
|
||||
typedef typename _Alloc::size_type size_type;
|
||||
size_type __strsize = __str.size();
|
||||
size_type __bytes = min(__strsize, __bufsiz - 1);
|
||||
_Traits::copy(__buf, __str.data(), __bytes);
|
||||
__buf[__bytes] = _CharT();
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_string<char>;
|
||||
extern template
|
||||
basic_istream<char>&
|
||||
operator>>(basic_istream<char>&, string&);
|
||||
extern template
|
||||
basic_ostream<char>&
|
||||
operator<<(basic_ostream<char>&, const string&);
|
||||
extern template
|
||||
basic_istream<char>&
|
||||
getline(basic_istream<char>&, string&, char);
|
||||
extern template
|
||||
basic_istream<char>&
|
||||
getline(basic_istream<char>&, string&);
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_string<wchar_t>;
|
||||
extern template
|
||||
basic_istream<wchar_t>&
|
||||
operator>>(basic_istream<wchar_t>&, wstring&);
|
||||
extern template
|
||||
basic_ostream<wchar_t>&
|
||||
operator<<(basic_ostream<wchar_t>&, const wstring&);
|
||||
extern template
|
||||
basic_istream<wchar_t>&
|
||||
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
|
||||
extern template
|
||||
basic_istream<wchar_t>&
|
||||
getline(basic_istream<wchar_t>&, wstring&);
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
899
TBE/MinGW/include/c++/3.2.3/bits/boost_concept_check.h
Normal file
899
TBE/MinGW/include/c++/3.2.3/bits/boost_concept_check.h
Normal file
@@ -0,0 +1,899 @@
|
||||
//
|
||||
// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
|
||||
// sell and distribute this software is granted provided this
|
||||
// copyright notice appears in all copies. This software is provided
|
||||
// "as is" without express or implied warranty, and with no claim as
|
||||
// to its suitability for any purpose.
|
||||
//
|
||||
|
||||
// GCC Note: based on version 1.12.0 of the Boost library.
|
||||
|
||||
/** @file boost_concept_check.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _GLIBCPP_BOOST_CONCEPT_CHECK
|
||||
#define _GLIBCPP_BOOST_CONCEPT_CHECK 1
|
||||
|
||||
#pragma GCC system_header
|
||||
#include <cstddef> // for ptrdiff_t, used next
|
||||
#include <bits/stl_iterator_base_types.h> // for traits and tags
|
||||
#include <utility> // for pair<>
|
||||
|
||||
|
||||
namespace __gnu_cxx
|
||||
{
|
||||
|
||||
#define _IsUnused __attribute__ ((__unused__))
|
||||
|
||||
// When the C-C code is in use, we would like this function to do as little
|
||||
// as possible at runtime, use as few resources as possible, and hopefully
|
||||
// be elided out of existence... hmmm.
|
||||
template <class _Concept>
|
||||
inline void __function_requires()
|
||||
{
|
||||
void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
|
||||
}
|
||||
|
||||
|
||||
// ??? Should the "concept_checking*" structs begin with more than _ ?
|
||||
#define _GLIBCPP_CLASS_REQUIRES(_type_var, _ns, _concept) \
|
||||
typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
|
||||
template <_func##_type_var##_concept _Tp1> \
|
||||
struct _concept_checking##_type_var##_concept { }; \
|
||||
typedef _concept_checking##_type_var##_concept< \
|
||||
&_ns::_concept <_type_var>::__constraints> \
|
||||
_concept_checking_typedef##_type_var##_concept
|
||||
|
||||
#define _GLIBCPP_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
|
||||
typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
|
||||
template <_func##_type_var1##_type_var2##_concept _Tp1> \
|
||||
struct _concept_checking##_type_var1##_type_var2##_concept { }; \
|
||||
typedef _concept_checking##_type_var1##_type_var2##_concept< \
|
||||
&_ns::_concept <_type_var1,_type_var2>::__constraints> \
|
||||
_concept_checking_typedef##_type_var1##_type_var2##_concept
|
||||
|
||||
#define _GLIBCPP_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
|
||||
typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
|
||||
template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
|
||||
struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
|
||||
typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
|
||||
&_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints> \
|
||||
_concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
|
||||
|
||||
#define _GLIBCPP_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
|
||||
typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
|
||||
template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
|
||||
struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
|
||||
typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
|
||||
&_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
|
||||
_concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
|
||||
|
||||
|
||||
template <class _Tp1, class _Tp2>
|
||||
struct _Aux_require_same { };
|
||||
|
||||
template <class _Tp>
|
||||
struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
|
||||
|
||||
template <class _Tp1, class _Tp2>
|
||||
struct _SameTypeConcept
|
||||
{
|
||||
void __constraints() {
|
||||
typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _IntegerConcept {
|
||||
void __constraints() {
|
||||
__error_type_must_be_an_integer_type();
|
||||
}
|
||||
};
|
||||
template <> struct _IntegerConcept<short> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
|
||||
template <> struct _IntegerConcept<int> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<long> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<long long> { void __constraints() {} };
|
||||
template <> struct _IntegerConcept<unsigned long long>
|
||||
{ void __constraints() {} };
|
||||
|
||||
template <class _Tp>
|
||||
struct _SignedIntegerConcept {
|
||||
void __constraints() {
|
||||
__error_type_must_be_a_signed_integer_type();
|
||||
}
|
||||
};
|
||||
template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
|
||||
template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
|
||||
template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
|
||||
template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
|
||||
|
||||
template <class _Tp>
|
||||
struct _UnsignedIntegerConcept {
|
||||
void __constraints() {
|
||||
__error_type_must_be_an_unsigned_integer_type();
|
||||
}
|
||||
};
|
||||
template <> struct _UnsignedIntegerConcept<unsigned short>
|
||||
{ void __constraints() {} };
|
||||
template <> struct _UnsignedIntegerConcept<unsigned int>
|
||||
{ void __constraints() {} };
|
||||
template <> struct _UnsignedIntegerConcept<unsigned long>
|
||||
{ void __constraints() {} };
|
||||
template <> struct _UnsignedIntegerConcept<unsigned long long>
|
||||
{ void __constraints() {} };
|
||||
|
||||
//===========================================================================
|
||||
// Basic Concepts
|
||||
|
||||
template <class _Tp>
|
||||
struct _DefaultConstructibleConcept
|
||||
{
|
||||
void __constraints() {
|
||||
_Tp __a _IsUnused; // require default constructor
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _AssignableConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__a = __a; // require assignment operator
|
||||
__const_constraints(__a);
|
||||
}
|
||||
void __const_constraints(const _Tp& __b) {
|
||||
__a = __b; // const required for argument to assignment
|
||||
}
|
||||
_Tp __a;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _CopyConstructibleConcept
|
||||
{
|
||||
void __constraints() {
|
||||
_Tp __a(__b); // require copy constructor
|
||||
_Tp* __ptr _IsUnused = &__a; // require address of operator
|
||||
__const_constraints(__a);
|
||||
}
|
||||
void __const_constraints(const _Tp& __a) {
|
||||
_Tp __c(__a) _IsUnused; // require const copy constructor
|
||||
const _Tp* __ptr _IsUnused = &__a; // require const address of operator
|
||||
}
|
||||
_Tp __b;
|
||||
};
|
||||
|
||||
// The SGI STL version of Assignable requires copy constructor and operator=
|
||||
template <class _Tp>
|
||||
struct _SGIAssignableConcept
|
||||
{
|
||||
void __constraints() {
|
||||
_Tp __b(__a) _IsUnused;
|
||||
__a = __a; // require assignment operator
|
||||
__const_constraints(__a);
|
||||
}
|
||||
void __const_constraints(const _Tp& __b) {
|
||||
_Tp __c(__b) _IsUnused;
|
||||
__a = __b; // const required for argument to assignment
|
||||
}
|
||||
_Tp __a;
|
||||
};
|
||||
|
||||
template <class _From, class _To>
|
||||
struct _ConvertibleConcept
|
||||
{
|
||||
void __constraints() {
|
||||
_To __y _IsUnused = __x;
|
||||
}
|
||||
_From __x;
|
||||
};
|
||||
|
||||
// The C++ standard requirements for many concepts talk about return
|
||||
// types that must be "convertible to bool". The problem with this
|
||||
// requirement is that it leaves the door open for evil proxies that
|
||||
// define things like operator|| with strange return types. Two
|
||||
// possible solutions are:
|
||||
// 1) require the return type to be exactly bool
|
||||
// 2) stay with convertible to bool, and also
|
||||
// specify stuff about all the logical operators.
|
||||
// For now we just test for convertible to bool.
|
||||
template <class _Tp>
|
||||
void __aux_require_boolean_expr(const _Tp& __t) {
|
||||
bool __x _IsUnused = __t;
|
||||
}
|
||||
|
||||
// FIXME
|
||||
template <class _Tp>
|
||||
struct _EqualityComparableConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__aux_require_boolean_expr(__a == __b);
|
||||
__aux_require_boolean_expr(__a != __b);
|
||||
}
|
||||
_Tp __a, __b;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _LessThanComparableConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__aux_require_boolean_expr(__a < __b);
|
||||
}
|
||||
_Tp __a, __b;
|
||||
};
|
||||
|
||||
// This is equivalent to SGI STL's LessThanComparable.
|
||||
template <class _Tp>
|
||||
struct _ComparableConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__aux_require_boolean_expr(__a < __b);
|
||||
__aux_require_boolean_expr(__a > __b);
|
||||
__aux_require_boolean_expr(__a <= __b);
|
||||
__aux_require_boolean_expr(__a >= __b);
|
||||
}
|
||||
_Tp __a, __b;
|
||||
};
|
||||
|
||||
#define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
|
||||
template <class _First, class _Second> \
|
||||
struct _NAME { \
|
||||
void __constraints() { (void)__constraints_(); } \
|
||||
bool __constraints_() { \
|
||||
return __a _OP __b; \
|
||||
} \
|
||||
_First __a; \
|
||||
_Second __b; \
|
||||
}
|
||||
|
||||
#define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
|
||||
template <class _Ret, class _First, class _Second> \
|
||||
struct _NAME { \
|
||||
void __constraints() { (void)__constraints_(); } \
|
||||
_Ret __constraints_() { \
|
||||
return __a _OP __b; \
|
||||
} \
|
||||
_First __a; \
|
||||
_Second __b; \
|
||||
}
|
||||
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
|
||||
|
||||
_GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
|
||||
_GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
|
||||
|
||||
#undef _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
|
||||
#undef _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT
|
||||
|
||||
//===========================================================================
|
||||
// Function Object Concepts
|
||||
|
||||
template <class _Func, class _Return>
|
||||
struct _GeneratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
const _Return& __r _IsUnused = __f();// require operator() member function
|
||||
}
|
||||
_Func __f;
|
||||
};
|
||||
|
||||
|
||||
template <class _Func>
|
||||
struct _GeneratorConcept<_Func,void>
|
||||
{
|
||||
void __constraints() {
|
||||
__f(); // require operator() member function
|
||||
}
|
||||
_Func __f;
|
||||
};
|
||||
|
||||
template <class _Func, class _Return, class _Arg>
|
||||
struct _UnaryFunctionConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__r = __f(__arg); // require operator()
|
||||
}
|
||||
_Func __f;
|
||||
_Arg __arg;
|
||||
_Return __r;
|
||||
};
|
||||
|
||||
template <class _Func, class _Arg>
|
||||
struct _UnaryFunctionConcept<_Func, void, _Arg> {
|
||||
void __constraints() {
|
||||
__f(__arg); // require operator()
|
||||
}
|
||||
_Func __f;
|
||||
_Arg __arg;
|
||||
};
|
||||
|
||||
template <class _Func, class _Return, class _First, class _Second>
|
||||
struct _BinaryFunctionConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__r = __f(__first, __second); // require operator()
|
||||
}
|
||||
_Func __f;
|
||||
_First __first;
|
||||
_Second __second;
|
||||
_Return __r;
|
||||
};
|
||||
|
||||
template <class _Func, class _First, class _Second>
|
||||
struct _BinaryFunctionConcept<_Func, void, _First, _Second>
|
||||
{
|
||||
void __constraints() {
|
||||
__f(__first, __second); // require operator()
|
||||
}
|
||||
_Func __f;
|
||||
_First __first;
|
||||
_Second __second;
|
||||
};
|
||||
|
||||
template <class _Func, class _Arg>
|
||||
struct _UnaryPredicateConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__aux_require_boolean_expr(__f(__arg)); // require op() returning bool
|
||||
}
|
||||
_Func __f;
|
||||
_Arg __arg;
|
||||
};
|
||||
|
||||
template <class _Func, class _First, class _Second>
|
||||
struct _BinaryPredicateConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool
|
||||
}
|
||||
_Func __f;
|
||||
_First __a;
|
||||
_Second __b;
|
||||
};
|
||||
|
||||
// use this when functor is used inside a container class like std::set
|
||||
template <class _Func, class _First, class _Second>
|
||||
struct _Const_BinaryPredicateConcept {
|
||||
void __constraints() {
|
||||
__const_constraints(__f);
|
||||
}
|
||||
void __const_constraints(const _Func& __fun) {
|
||||
__function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
|
||||
// operator() must be a const member function
|
||||
__aux_require_boolean_expr(__fun(__a, __b));
|
||||
}
|
||||
_Func __f;
|
||||
_First __a;
|
||||
_Second __b;
|
||||
};
|
||||
|
||||
//===========================================================================
|
||||
// Iterator Concepts
|
||||
|
||||
template <class _Tp>
|
||||
struct _TrivialIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _DefaultConstructibleConcept<_Tp> >();
|
||||
__function_requires< _AssignableConcept<_Tp> >();
|
||||
__function_requires< _EqualityComparableConcept<_Tp> >();
|
||||
// typedef typename std::iterator_traits<_Tp>::value_type _V;
|
||||
(void)*__i; // require dereference operator
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _Mutable_TrivialIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _TrivialIteratorConcept<_Tp> >();
|
||||
*__i = *__j; // require dereference and assignment
|
||||
}
|
||||
_Tp __i, __j;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _InputIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _TrivialIteratorConcept<_Tp> >();
|
||||
// require iterator_traits typedef's
|
||||
typedef typename std::iterator_traits<_Tp>::difference_type _D;
|
||||
// __function_requires< _SignedIntegerConcept<_D> >();
|
||||
typedef typename std::iterator_traits<_Tp>::reference _R;
|
||||
typedef typename std::iterator_traits<_Tp>::pointer _Pt;
|
||||
typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
|
||||
__function_requires< _ConvertibleConcept<
|
||||
typename std::iterator_traits<_Tp>::iterator_category,
|
||||
std::input_iterator_tag> >();
|
||||
++__i; // require preincrement operator
|
||||
__i++; // require postincrement operator
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
template <class _Tp, class _ValueT>
|
||||
struct _OutputIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _AssignableConcept<_Tp> >();
|
||||
++__i; // require preincrement operator
|
||||
__i++; // require postincrement operator
|
||||
*__i++ = __t; // require postincrement and assignment
|
||||
}
|
||||
_Tp __i;
|
||||
_ValueT __t;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _ForwardIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _InputIteratorConcept<_Tp> >();
|
||||
__function_requires< _ConvertibleConcept<
|
||||
typename std::iterator_traits<_Tp>::iterator_category,
|
||||
std::forward_iterator_tag> >();
|
||||
typedef typename std::iterator_traits<_Tp>::reference _R;
|
||||
_R __r _IsUnused = *__i;
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _Mutable_ForwardIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _ForwardIteratorConcept<_Tp> >();
|
||||
*__i++ = *__i; // require postincrement and assignment
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _BidirectionalIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _ForwardIteratorConcept<_Tp> >();
|
||||
__function_requires< _ConvertibleConcept<
|
||||
typename std::iterator_traits<_Tp>::iterator_category,
|
||||
std::bidirectional_iterator_tag> >();
|
||||
--__i; // require predecrement operator
|
||||
__i--; // require postdecrement operator
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _Mutable_BidirectionalIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _BidirectionalIteratorConcept<_Tp> >();
|
||||
__function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
|
||||
*__i-- = *__i; // require postdecrement and assignment
|
||||
}
|
||||
_Tp __i;
|
||||
};
|
||||
|
||||
|
||||
template <class _Tp>
|
||||
struct _RandomAccessIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _BidirectionalIteratorConcept<_Tp> >();
|
||||
__function_requires< _ComparableConcept<_Tp> >();
|
||||
__function_requires< _ConvertibleConcept<
|
||||
typename std::iterator_traits<_Tp>::iterator_category,
|
||||
std::random_access_iterator_tag> >();
|
||||
// ??? We don't use _R, are we just checking for "referenceability"?
|
||||
typedef typename std::iterator_traits<_Tp>::reference _R;
|
||||
|
||||
__i += __n; // require assignment addition operator
|
||||
__i = __i + __n; __i = __n + __i; // require addition with difference type
|
||||
__i -= __n; // require assignment subtraction op
|
||||
__i = __i - __n; // require subtraction with
|
||||
// difference type
|
||||
__n = __i - __j; // require difference operator
|
||||
(void)__i[__n]; // require element access operator
|
||||
}
|
||||
_Tp __a, __b;
|
||||
_Tp __i, __j;
|
||||
typename std::iterator_traits<_Tp>::difference_type __n;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _Mutable_RandomAccessIteratorConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _RandomAccessIteratorConcept<_Tp> >();
|
||||
__function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
|
||||
__i[__n] = *__i; // require element access and assignment
|
||||
}
|
||||
_Tp __i;
|
||||
typename std::iterator_traits<_Tp>::difference_type __n;
|
||||
};
|
||||
|
||||
//===========================================================================
|
||||
// Container Concepts
|
||||
|
||||
template <class _Container>
|
||||
struct _ContainerConcept
|
||||
{
|
||||
typedef typename _Container::value_type _Value_type;
|
||||
typedef typename _Container::difference_type _Difference_type;
|
||||
typedef typename _Container::size_type _Size_type;
|
||||
typedef typename _Container::const_reference _Const_reference;
|
||||
typedef typename _Container::const_pointer _Const_pointer;
|
||||
typedef typename _Container::const_iterator _Const_iterator;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires< _InputIteratorConcept<_Const_iterator> >();
|
||||
__function_requires< _AssignableConcept<_Container> >();
|
||||
const _Container __c;
|
||||
__i = __c.begin();
|
||||
__i = __c.end();
|
||||
__n = __c.size();
|
||||
__n = __c.max_size();
|
||||
__b = __c.empty();
|
||||
}
|
||||
bool __b;
|
||||
_Const_iterator __i;
|
||||
_Size_type __n;
|
||||
};
|
||||
|
||||
template <class _Container>
|
||||
struct _Mutable_ContainerConcept
|
||||
{
|
||||
typedef typename _Container::value_type _Value_type;
|
||||
typedef typename _Container::reference _Reference;
|
||||
typedef typename _Container::iterator _Iterator;
|
||||
typedef typename _Container::pointer _Pointer;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires< _ContainerConcept<_Container> >();
|
||||
__function_requires< _AssignableConcept<_Value_type> >();
|
||||
__function_requires< _InputIteratorConcept<_Iterator> >();
|
||||
|
||||
__i = __c.begin();
|
||||
__i = __c.end();
|
||||
__c.swap(__c2);
|
||||
}
|
||||
_Iterator __i;
|
||||
_Container __c, __c2;
|
||||
};
|
||||
|
||||
template <class _ForwardContainer>
|
||||
struct _ForwardContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _ContainerConcept<_ForwardContainer> >();
|
||||
typedef typename _ForwardContainer::const_iterator _Const_iterator;
|
||||
__function_requires< _ForwardIteratorConcept<_Const_iterator> >();
|
||||
}
|
||||
};
|
||||
|
||||
template <class _ForwardContainer>
|
||||
struct _Mutable_ForwardContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _ForwardContainerConcept<_ForwardContainer> >();
|
||||
__function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
|
||||
typedef typename _ForwardContainer::iterator _Iterator;
|
||||
__function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
|
||||
}
|
||||
};
|
||||
|
||||
template <class _ReversibleContainer>
|
||||
struct _ReversibleContainerConcept
|
||||
{
|
||||
typedef typename _ReversibleContainer::const_iterator _Const_iterator;
|
||||
typedef typename _ReversibleContainer::const_reverse_iterator
|
||||
_Const_reverse_iterator;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
|
||||
__function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
|
||||
__function_requires<
|
||||
_BidirectionalIteratorConcept<_Const_reverse_iterator> >();
|
||||
|
||||
const _ReversibleContainer __c;
|
||||
_Const_reverse_iterator __i = __c.rbegin();
|
||||
__i = __c.rend();
|
||||
}
|
||||
};
|
||||
|
||||
template <class _ReversibleContainer>
|
||||
struct _Mutable_ReversibleContainerConcept
|
||||
{
|
||||
typedef typename _ReversibleContainer::iterator _Iterator;
|
||||
typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
|
||||
__function_requires<
|
||||
_Mutable_ForwardContainerConcept<_ReversibleContainer> >();
|
||||
__function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
|
||||
__function_requires<
|
||||
_Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
|
||||
|
||||
_Reverse_iterator __i = __c.rbegin();
|
||||
__i = __c.rend();
|
||||
}
|
||||
_ReversibleContainer __c;
|
||||
};
|
||||
|
||||
template <class _RandomAccessContainer>
|
||||
struct _RandomAccessContainerConcept
|
||||
{
|
||||
typedef typename _RandomAccessContainer::size_type _Size_type;
|
||||
typedef typename _RandomAccessContainer::const_reference _Const_reference;
|
||||
typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
|
||||
typedef typename _RandomAccessContainer::const_reverse_iterator
|
||||
_Const_reverse_iterator;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_ReversibleContainerConcept<_RandomAccessContainer> >();
|
||||
__function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
|
||||
__function_requires<
|
||||
_RandomAccessIteratorConcept<_Const_reverse_iterator> >();
|
||||
|
||||
const _RandomAccessContainer __c;
|
||||
_Const_reference __r _IsUnused = __c[__n];
|
||||
}
|
||||
_Size_type __n;
|
||||
};
|
||||
|
||||
template <class _RandomAccessContainer>
|
||||
struct _Mutable_RandomAccessContainerConcept
|
||||
{
|
||||
typedef typename _RandomAccessContainer::size_type _Size_type;
|
||||
typedef typename _RandomAccessContainer::reference _Reference;
|
||||
typedef typename _RandomAccessContainer::iterator _Iterator;
|
||||
typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_RandomAccessContainerConcept<_RandomAccessContainer> >();
|
||||
__function_requires<
|
||||
_Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
|
||||
__function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
|
||||
__function_requires<
|
||||
_Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
|
||||
|
||||
_Reference __r _IsUnused = __c[__i];
|
||||
}
|
||||
_Size_type __i;
|
||||
_RandomAccessContainer __c;
|
||||
};
|
||||
|
||||
// A Sequence is inherently mutable
|
||||
template <class _Sequence>
|
||||
struct _SequenceConcept
|
||||
{
|
||||
typedef typename _Sequence::reference _Reference;
|
||||
typedef typename _Sequence::const_reference _Const_reference;
|
||||
|
||||
void __constraints() {
|
||||
// Matt Austern's book puts DefaultConstructible here, the C++
|
||||
// standard places it in Container
|
||||
// function_requires< DefaultConstructible<Sequence> >();
|
||||
__function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
|
||||
__function_requires< _DefaultConstructibleConcept<_Sequence> >();
|
||||
|
||||
_Sequence
|
||||
__c(__n) _IsUnused,
|
||||
__c2(__n, __t) _IsUnused,
|
||||
__c3(__first, __last) _IsUnused;
|
||||
|
||||
__c.insert(__p, __t);
|
||||
__c.insert(__p, __n, __t);
|
||||
__c.insert(__p, __first, __last);
|
||||
|
||||
__c.erase(__p);
|
||||
__c.erase(__p, __q);
|
||||
|
||||
_Reference __r _IsUnused = __c.front();
|
||||
|
||||
__const_constraints(__c);
|
||||
}
|
||||
void __const_constraints(const _Sequence& __c) {
|
||||
_Const_reference __r _IsUnused = __c.front();
|
||||
}
|
||||
typename _Sequence::value_type __t;
|
||||
typename _Sequence::size_type __n;
|
||||
typename _Sequence::value_type *__first, *__last;
|
||||
typename _Sequence::iterator __p, __q;
|
||||
};
|
||||
|
||||
template <class _FrontInsertionSequence>
|
||||
struct _FrontInsertionSequenceConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _SequenceConcept<_FrontInsertionSequence> >();
|
||||
|
||||
__c.push_front(__t);
|
||||
__c.pop_front();
|
||||
}
|
||||
_FrontInsertionSequence __c;
|
||||
typename _FrontInsertionSequence::value_type __t;
|
||||
};
|
||||
|
||||
template <class _BackInsertionSequence>
|
||||
struct _BackInsertionSequenceConcept
|
||||
{
|
||||
typedef typename _BackInsertionSequence::reference _Reference;
|
||||
typedef typename _BackInsertionSequence::const_reference _Const_reference;
|
||||
|
||||
void __constraints() {
|
||||
__function_requires< _SequenceConcept<_BackInsertionSequence> >();
|
||||
|
||||
__c.push_back(__t);
|
||||
__c.pop_back();
|
||||
_Reference __r _IsUnused = __c.back();
|
||||
}
|
||||
void __const_constraints(const _BackInsertionSequence& __c) {
|
||||
_Const_reference __r _IsUnused = __c.back();
|
||||
};
|
||||
_BackInsertionSequence __c;
|
||||
typename _BackInsertionSequence::value_type __t;
|
||||
};
|
||||
|
||||
template <class _AssociativeContainer>
|
||||
struct _AssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
|
||||
__function_requires<
|
||||
_DefaultConstructibleConcept<_AssociativeContainer> >();
|
||||
|
||||
__i = __c.find(__k);
|
||||
__r = __c.equal_range(__k);
|
||||
__c.erase(__k);
|
||||
__c.erase(__i);
|
||||
__c.erase(__r.first, __r.second);
|
||||
__const_constraints(__c);
|
||||
}
|
||||
void __const_constraints(const _AssociativeContainer& __c) {
|
||||
__ci = __c.find(__k);
|
||||
__n = __c.count(__k);
|
||||
__cr = __c.equal_range(__k);
|
||||
}
|
||||
typedef typename _AssociativeContainer::iterator _Iterator;
|
||||
typedef typename _AssociativeContainer::const_iterator _Const_iterator;
|
||||
|
||||
_AssociativeContainer __c;
|
||||
_Iterator __i;
|
||||
std::pair<_Iterator,_Iterator> __r;
|
||||
_Const_iterator __ci;
|
||||
std::pair<_Const_iterator,_Const_iterator> __cr;
|
||||
typename _AssociativeContainer::key_type __k;
|
||||
typename _AssociativeContainer::size_type __n;
|
||||
};
|
||||
|
||||
template <class _UniqueAssociativeContainer>
|
||||
struct _UniqueAssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_AssociativeContainerConcept<_UniqueAssociativeContainer> >();
|
||||
|
||||
_UniqueAssociativeContainer __c(__first, __last);
|
||||
|
||||
__pos_flag = __c.insert(__t);
|
||||
__c.insert(__first, __last);
|
||||
}
|
||||
std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
|
||||
typename _UniqueAssociativeContainer::value_type __t;
|
||||
typename _UniqueAssociativeContainer::value_type *__first, *__last;
|
||||
};
|
||||
|
||||
template <class _MultipleAssociativeContainer>
|
||||
struct _MultipleAssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_AssociativeContainerConcept<_MultipleAssociativeContainer> >();
|
||||
|
||||
_MultipleAssociativeContainer __c(__first, __last);
|
||||
|
||||
__pos = __c.insert(__t);
|
||||
__c.insert(__first, __last);
|
||||
|
||||
}
|
||||
typename _MultipleAssociativeContainer::iterator __pos _IsUnused;
|
||||
typename _MultipleAssociativeContainer::value_type __t;
|
||||
typename _MultipleAssociativeContainer::value_type *__first, *__last;
|
||||
};
|
||||
|
||||
template <class _SimpleAssociativeContainer>
|
||||
struct _SimpleAssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_AssociativeContainerConcept<_SimpleAssociativeContainer> >();
|
||||
typedef typename _SimpleAssociativeContainer::key_type _Key_type;
|
||||
typedef typename _SimpleAssociativeContainer::value_type _Value_type;
|
||||
typedef typename _Aux_require_same<_Key_type, _Value_type>::_Type
|
||||
_Requqired;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _SimpleAssociativeContainer>
|
||||
struct _PairAssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_AssociativeContainerConcept<_SimpleAssociativeContainer> >();
|
||||
typedef typename _SimpleAssociativeContainer::key_type _Key_type;
|
||||
typedef typename _SimpleAssociativeContainer::value_type _Value_type;
|
||||
typedef typename _SimpleAssociativeContainer::mapped_type _Mapped_type;
|
||||
typedef std::pair<const _Key_type, _Mapped_type> _Required_value_type;
|
||||
typedef typename _Aux_require_same<_Value_type,
|
||||
_Required_value_type>::_Type _Required;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _SortedAssociativeContainer>
|
||||
struct _SortedAssociativeContainerConcept
|
||||
{
|
||||
void __constraints() {
|
||||
__function_requires<
|
||||
_AssociativeContainerConcept<_SortedAssociativeContainer> >();
|
||||
__function_requires<
|
||||
_ReversibleContainerConcept<_SortedAssociativeContainer> >();
|
||||
|
||||
_SortedAssociativeContainer
|
||||
__c(__kc) _IsUnused,
|
||||
__c2(__first, __last) _IsUnused,
|
||||
__c3(__first, __last, __kc) _IsUnused;
|
||||
|
||||
__p = __c.upper_bound(__k);
|
||||
__p = __c.lower_bound(__k);
|
||||
__r = __c.equal_range(__k);
|
||||
|
||||
__c.insert(__p, __t);
|
||||
}
|
||||
void __const_constraints(const _SortedAssociativeContainer& __c) {
|
||||
__kc = __c.key_comp();
|
||||
__vc = __c.value_comp();
|
||||
|
||||
__cp = __c.upper_bound(__k);
|
||||
__cp = __c.lower_bound(__k);
|
||||
__cr = __c.equal_range(__k);
|
||||
}
|
||||
typename _SortedAssociativeContainer::key_compare __kc;
|
||||
typename _SortedAssociativeContainer::value_compare __vc;
|
||||
typename _SortedAssociativeContainer::value_type __t;
|
||||
typename _SortedAssociativeContainer::key_type __k;
|
||||
typedef typename _SortedAssociativeContainer::iterator _Iterator;
|
||||
typedef typename _SortedAssociativeContainer::const_iterator
|
||||
_Const_iterator;
|
||||
|
||||
_Iterator __p;
|
||||
_Const_iterator __cp;
|
||||
std::pair<_Iterator,_Iterator> __r;
|
||||
std::pair<_Const_iterator,_Const_iterator> __cr;
|
||||
typename _SortedAssociativeContainer::value_type *__first, *__last;
|
||||
};
|
||||
|
||||
// HashedAssociativeContainer
|
||||
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
#undef _IsUnused
|
||||
|
||||
#endif // _GLIBCPP_BOOST_CONCEPT_CHECK
|
||||
|
||||
|
||||
252
TBE/MinGW/include/c++/3.2.3/bits/char_traits.h
Normal file
252
TBE/MinGW/include/c++/3.2.3/bits/char_traits.h
Normal file
@@ -0,0 +1,252 @@
|
||||
// Character Traits for use by standard string and iostream -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 21 Strings library
|
||||
//
|
||||
|
||||
/** @file char_traits.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_CHAR_TRAITS_H
|
||||
#define _CPP_BITS_CHAR_TRAITS_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <cstring> // For memmove, memset, memchr
|
||||
#include <bits/fpos.h> // For streampos
|
||||
|
||||
namespace std
|
||||
{
|
||||
/// 21.1.2 Basis for explicit _Traits specialization
|
||||
/// NB: That for any given actual character type this definition is
|
||||
/// probably wrong.
|
||||
template<class _CharT>
|
||||
struct char_traits
|
||||
{
|
||||
typedef _CharT char_type;
|
||||
// Unsigned as wint_t is unsigned.
|
||||
typedef unsigned long int_type;
|
||||
typedef streampos pos_type;
|
||||
typedef streamoff off_type;
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
static void
|
||||
assign(char_type& __c1, const char_type& __c2);
|
||||
|
||||
static bool
|
||||
eq(const char_type& __c1, const char_type& __c2);
|
||||
|
||||
static bool
|
||||
lt(const char_type& __c1, const char_type& __c2);
|
||||
|
||||
static int
|
||||
compare(const char_type* __s1, const char_type* __s2, size_t __n);
|
||||
|
||||
static size_t
|
||||
length(const char_type* __s);
|
||||
|
||||
static const char_type*
|
||||
find(const char_type* __s, size_t __n, const char_type& __a);
|
||||
|
||||
static char_type*
|
||||
move(char_type* __s1, const char_type* __s2, size_t __n);
|
||||
|
||||
static char_type*
|
||||
copy(char_type* __s1, const char_type* __s2, size_t __n);
|
||||
|
||||
static char_type*
|
||||
assign(char_type* __s, size_t __n, char_type __a);
|
||||
|
||||
static char_type
|
||||
to_char_type(const int_type& __c);
|
||||
|
||||
static int_type
|
||||
to_int_type(const char_type& __c);
|
||||
|
||||
static bool
|
||||
eq_int_type(const int_type& __c1, const int_type& __c2);
|
||||
|
||||
static int_type
|
||||
eof();
|
||||
|
||||
static int_type
|
||||
not_eof(const int_type& __c);
|
||||
};
|
||||
|
||||
|
||||
/// 21.1.4 char_traits specializations
|
||||
template<>
|
||||
struct char_traits<char>
|
||||
{
|
||||
typedef char char_type;
|
||||
typedef int int_type;
|
||||
typedef streampos pos_type;
|
||||
typedef streamoff off_type;
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
static void
|
||||
assign(char_type& __c1, const char_type& __c2)
|
||||
{ __c1 = __c2; }
|
||||
|
||||
static bool
|
||||
eq(const char_type& __c1, const char_type& __c2)
|
||||
{ return __c1 == __c2; }
|
||||
|
||||
static bool
|
||||
lt(const char_type& __c1, const char_type& __c2)
|
||||
{ return __c1 < __c2; }
|
||||
|
||||
static int
|
||||
compare(const char_type* __s1, const char_type* __s2, size_t __n)
|
||||
{ return memcmp(__s1, __s2, __n); }
|
||||
|
||||
static size_t
|
||||
length(const char_type* __s)
|
||||
{ return strlen(__s); }
|
||||
|
||||
static const char_type*
|
||||
find(const char_type* __s, size_t __n, const char_type& __a)
|
||||
{ return static_cast<const char_type*>(memchr(__s, __a, __n)); }
|
||||
|
||||
static char_type*
|
||||
move(char_type* __s1, const char_type* __s2, size_t __n)
|
||||
{ return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
|
||||
|
||||
static char_type*
|
||||
copy(char_type* __s1, const char_type* __s2, size_t __n)
|
||||
{ return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
|
||||
|
||||
static char_type*
|
||||
assign(char_type* __s, size_t __n, char_type __a)
|
||||
{ return static_cast<char_type*>(memset(__s, __a, __n)); }
|
||||
|
||||
static char_type
|
||||
to_char_type(const int_type& __c)
|
||||
{ return static_cast<char_type>(__c); }
|
||||
|
||||
// To keep both the byte 0xff and the eof symbol 0xffffffff
|
||||
// from ending up as 0xffffffff.
|
||||
static int_type
|
||||
to_int_type(const char_type& __c)
|
||||
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
|
||||
|
||||
static bool
|
||||
eq_int_type(const int_type& __c1, const int_type& __c2)
|
||||
{ return __c1 == __c2; }
|
||||
|
||||
static int_type
|
||||
eof() { return static_cast<int_type>(EOF); }
|
||||
|
||||
static int_type
|
||||
not_eof(const int_type& __c)
|
||||
{ return (__c == eof()) ? 0 : __c; }
|
||||
};
|
||||
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
template<>
|
||||
struct char_traits<wchar_t>
|
||||
{
|
||||
typedef wchar_t char_type;
|
||||
typedef wint_t int_type;
|
||||
typedef streamoff off_type;
|
||||
typedef wstreampos pos_type;
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
static void
|
||||
assign(char_type& __c1, const char_type& __c2)
|
||||
{ __c1 = __c2; }
|
||||
|
||||
static bool
|
||||
eq(const char_type& __c1, const char_type& __c2)
|
||||
{ return __c1 == __c2; }
|
||||
|
||||
static bool
|
||||
lt(const char_type& __c1, const char_type& __c2)
|
||||
{ return __c1 < __c2; }
|
||||
|
||||
static int
|
||||
compare(const char_type* __s1, const char_type* __s2, size_t __n)
|
||||
{ return wmemcmp(__s1, __s2, __n); }
|
||||
|
||||
static size_t
|
||||
length(const char_type* __s)
|
||||
{ return wcslen(__s); }
|
||||
|
||||
static const char_type*
|
||||
find(const char_type* __s, size_t __n, const char_type& __a)
|
||||
{ return wmemchr(__s, __a, __n); }
|
||||
|
||||
static char_type*
|
||||
move(char_type* __s1, const char_type* __s2, int_type __n)
|
||||
{ return wmemmove(__s1, __s2, __n); }
|
||||
|
||||
static char_type*
|
||||
copy(char_type* __s1, const char_type* __s2, size_t __n)
|
||||
{ return wmemcpy(__s1, __s2, __n); }
|
||||
|
||||
static char_type*
|
||||
assign(char_type* __s, size_t __n, char_type __a)
|
||||
{ return wmemset(__s, __a, __n); }
|
||||
|
||||
static char_type
|
||||
to_char_type(const int_type& __c) { return char_type(__c); }
|
||||
|
||||
static int_type
|
||||
to_int_type(const char_type& __c) { return int_type(__c); }
|
||||
|
||||
static bool
|
||||
eq_int_type(const int_type& __c1, const int_type& __c2)
|
||||
{ return __c1 == __c2; }
|
||||
|
||||
static int_type
|
||||
eof() { return static_cast<int_type>(WEOF); }
|
||||
|
||||
static int_type
|
||||
not_eof(const int_type& __c)
|
||||
{ return eq_int_type(__c, eof()) ? 0 : __c; }
|
||||
};
|
||||
#endif //_GLIBCPP_USE_WCHAR_T
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
struct _Char_traits_match
|
||||
{
|
||||
_CharT _M_c;
|
||||
_Char_traits_match(_CharT const& __c) : _M_c(__c) { }
|
||||
|
||||
bool
|
||||
operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
54
TBE/MinGW/include/c++/3.2.3/bits/cmath.tcc
Normal file
54
TBE/MinGW/include/c++/3.2.3/bits/cmath.tcc
Normal file
@@ -0,0 +1,54 @@
|
||||
// -*- C++ -*- C math library.
|
||||
|
||||
// Copyright (C) 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// This file was written by Gabriel Dos Reis <gdr@codesourcery.com>
|
||||
|
||||
#ifndef _CPP_BITS_CMATH_TCC
|
||||
#define _CPP_BITS_CMATH_TCC 1
|
||||
|
||||
namespace std
|
||||
{
|
||||
export template<typename _Tp>
|
||||
_Tp
|
||||
__cmath_power(_Tp __x, unsigned int __n)
|
||||
{
|
||||
_Tp __y = __n % 2 ? __x : 1;
|
||||
|
||||
while (__n >>= 1)
|
||||
{
|
||||
__x = __x * __x;
|
||||
if (__n % 2)
|
||||
__y = __y * __x;
|
||||
}
|
||||
|
||||
return __y;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
337
TBE/MinGW/include/c++/3.2.3/bits/codecvt.h
Normal file
337
TBE/MinGW/include/c++/3.2.3/bits/codecvt.h
Normal file
@@ -0,0 +1,337 @@
|
||||
// Locale support (codecvt) -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2000, 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 22.2.1.5 Template class codecvt
|
||||
//
|
||||
|
||||
// Written by Benjamin Kosnik <bkoz@cygnus.com>
|
||||
|
||||
/** @file codecvt.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_CODECVT_H
|
||||
#define _CPP_BITS_CODECVT_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
// 22.2.1.5 Template class codecvt
|
||||
class codecvt_base
|
||||
{
|
||||
public:
|
||||
enum result
|
||||
{
|
||||
ok,
|
||||
partial,
|
||||
error,
|
||||
noconv
|
||||
};
|
||||
};
|
||||
|
||||
// Template class __codecvt_abstract_base
|
||||
// NB: An abstract base class that fills in the public inlines, so
|
||||
// that the specializations don't have to re-copy the public
|
||||
// interface.
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
class __codecvt_abstract_base
|
||||
: public locale::facet, public codecvt_base
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef codecvt_base::result result;
|
||||
typedef _InternT intern_type;
|
||||
typedef _ExternT extern_type;
|
||||
typedef _StateT state_type;
|
||||
|
||||
// 22.2.1.5.1 codecvt members
|
||||
result
|
||||
out(state_type& __state, const intern_type* __from,
|
||||
const intern_type* __from_end, const intern_type*& __from_next,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const
|
||||
{
|
||||
return this->do_out(__state, __from, __from_end, __from_next,
|
||||
__to, __to_end, __to_next);
|
||||
}
|
||||
|
||||
result
|
||||
unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const
|
||||
{ return this->do_unshift(__state, __to,__to_end,__to_next); }
|
||||
|
||||
result
|
||||
in(state_type& __state, const extern_type* __from,
|
||||
const extern_type* __from_end, const extern_type*& __from_next,
|
||||
intern_type* __to, intern_type* __to_end,
|
||||
intern_type*& __to_next) const
|
||||
{
|
||||
return this->do_in(__state, __from, __from_end, __from_next,
|
||||
__to, __to_end, __to_next);
|
||||
}
|
||||
|
||||
int
|
||||
encoding() const throw()
|
||||
{ return this->do_encoding(); }
|
||||
|
||||
bool
|
||||
always_noconv() const throw()
|
||||
{ return this->do_always_noconv(); }
|
||||
|
||||
int
|
||||
length(const state_type& __state, const extern_type* __from,
|
||||
const extern_type* __end, size_t __max) const
|
||||
{ return this->do_length(__state, __from, __end, __max); }
|
||||
|
||||
int
|
||||
max_length() const throw()
|
||||
{ return this->do_max_length(); }
|
||||
|
||||
protected:
|
||||
explicit
|
||||
__codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
|
||||
|
||||
virtual
|
||||
~__codecvt_abstract_base() { }
|
||||
|
||||
virtual result
|
||||
do_out(state_type& __state, const intern_type* __from,
|
||||
const intern_type* __from_end, const intern_type*& __from_next,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const = 0;
|
||||
|
||||
virtual result
|
||||
do_unshift(state_type& __state, extern_type* __to,
|
||||
extern_type* __to_end, extern_type*& __to_next) const = 0;
|
||||
|
||||
virtual result
|
||||
do_in(state_type& __state, const extern_type* __from,
|
||||
const extern_type* __from_end, const extern_type*& __from_next,
|
||||
intern_type* __to, intern_type* __to_end,
|
||||
intern_type*& __to_next) const = 0;
|
||||
|
||||
virtual int
|
||||
do_encoding() const throw() = 0;
|
||||
|
||||
virtual bool
|
||||
do_always_noconv() const throw() = 0;
|
||||
|
||||
virtual int
|
||||
do_length(const state_type&, const extern_type* __from,
|
||||
const extern_type* __end, size_t __max) const = 0;
|
||||
|
||||
virtual int
|
||||
do_max_length() const throw() = 0;
|
||||
};
|
||||
|
||||
// 22.2.1.5 Template class codecvt
|
||||
// NB: Generic, mostly useless implementation.
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
class codecvt
|
||||
: public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef codecvt_base::result result;
|
||||
typedef _InternT intern_type;
|
||||
typedef _ExternT extern_type;
|
||||
typedef _StateT state_type;
|
||||
|
||||
public:
|
||||
static locale::id id;
|
||||
|
||||
explicit
|
||||
codecvt(size_t __refs = 0)
|
||||
: __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
|
||||
|
||||
protected:
|
||||
virtual
|
||||
~codecvt() { }
|
||||
|
||||
virtual result
|
||||
do_out(state_type& __state, const intern_type* __from,
|
||||
const intern_type* __from_end, const intern_type*& __from_next,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_unshift(state_type& __state, extern_type* __to,
|
||||
extern_type* __to_end, extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_in(state_type& __state, const extern_type* __from,
|
||||
const extern_type* __from_end, const extern_type*& __from_next,
|
||||
intern_type* __to, intern_type* __to_end,
|
||||
intern_type*& __to_next) const;
|
||||
|
||||
virtual int
|
||||
do_encoding() const throw();
|
||||
|
||||
virtual bool
|
||||
do_always_noconv() const throw();
|
||||
|
||||
virtual int
|
||||
do_length(const state_type&, const extern_type* __from,
|
||||
const extern_type* __end, size_t __max) const;
|
||||
|
||||
virtual int
|
||||
do_max_length() const throw();
|
||||
};
|
||||
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
locale::id codecvt<_InternT, _ExternT, _StateT>::id;
|
||||
|
||||
// codecvt<char, char, mbstate_t> required specialization
|
||||
template<>
|
||||
class codecvt<char, char, mbstate_t>
|
||||
: public __codecvt_abstract_base<char, char, mbstate_t>
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef char intern_type;
|
||||
typedef char extern_type;
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
public:
|
||||
static locale::id id;
|
||||
|
||||
explicit
|
||||
codecvt(size_t __refs = 0);
|
||||
|
||||
protected:
|
||||
virtual
|
||||
~codecvt();
|
||||
|
||||
virtual result
|
||||
do_out(state_type& __state, const intern_type* __from,
|
||||
const intern_type* __from_end, const intern_type*& __from_next,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_unshift(state_type& __state, extern_type* __to,
|
||||
extern_type* __to_end, extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_in(state_type& __state, const extern_type* __from,
|
||||
const extern_type* __from_end, const extern_type*& __from_next,
|
||||
intern_type* __to, intern_type* __to_end,
|
||||
intern_type*& __to_next) const;
|
||||
|
||||
virtual int
|
||||
do_encoding() const throw();
|
||||
|
||||
virtual bool
|
||||
do_always_noconv() const throw();
|
||||
|
||||
virtual int
|
||||
do_length(const state_type&, const extern_type* __from,
|
||||
const extern_type* __end, size_t __max) const;
|
||||
|
||||
virtual int
|
||||
do_max_length() const throw();
|
||||
};
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
// codecvt<wchar_t, char, mbstate_t> required specialization
|
||||
template<>
|
||||
class codecvt<wchar_t, char, mbstate_t>
|
||||
: public __codecvt_abstract_base<wchar_t, char, mbstate_t>
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef wchar_t intern_type;
|
||||
typedef char extern_type;
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
public:
|
||||
static locale::id id;
|
||||
|
||||
explicit
|
||||
codecvt(size_t __refs = 0);
|
||||
|
||||
protected:
|
||||
virtual
|
||||
~codecvt();
|
||||
|
||||
virtual result
|
||||
do_out(state_type& __state, const intern_type* __from,
|
||||
const intern_type* __from_end, const intern_type*& __from_next,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_unshift(state_type& __state,
|
||||
extern_type* __to, extern_type* __to_end,
|
||||
extern_type*& __to_next) const;
|
||||
|
||||
virtual result
|
||||
do_in(state_type& __state,
|
||||
const extern_type* __from, const extern_type* __from_end,
|
||||
const extern_type*& __from_next,
|
||||
intern_type* __to, intern_type* __to_end,
|
||||
intern_type*& __to_next) const;
|
||||
|
||||
virtual
|
||||
int do_encoding() const throw();
|
||||
|
||||
virtual
|
||||
bool do_always_noconv() const throw();
|
||||
|
||||
virtual
|
||||
int do_length(const state_type&, const extern_type* __from,
|
||||
const extern_type* __end, size_t __max) const;
|
||||
|
||||
virtual int
|
||||
do_max_length() const throw();
|
||||
};
|
||||
#endif //_GLIBCPP_USE_WCHAR_T
|
||||
|
||||
// 22.2.1.6 Template class codecvt_byname
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
|
||||
{
|
||||
public:
|
||||
explicit
|
||||
codecvt_byname(const char*, size_t __refs = 0)
|
||||
: codecvt<_InternT, _ExternT, _StateT>(__refs) { }
|
||||
|
||||
protected:
|
||||
virtual
|
||||
~codecvt_byname() { }
|
||||
};
|
||||
|
||||
// Include host and configuration specific partial specializations
|
||||
// with additional functionality, if possible.
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
#include <bits/codecvt_specializations.h>
|
||||
#endif
|
||||
|
||||
#endif // _CPP_BITS_CODECVT_H
|
||||
86
TBE/MinGW/include/c++/3.2.3/bits/concept_check.h
Normal file
86
TBE/MinGW/include/c++/3.2.3/bits/concept_check.h
Normal file
@@ -0,0 +1,86 @@
|
||||
// Concept-checking control -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/** @file concept_check.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _GLIBCPP_CONCEPT_CHECK
|
||||
#define _GLIBCPP_CONCEPT_CHECK 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++config.h>
|
||||
|
||||
// All places in libstdc++-v3 where these are used, or /might/ be used, or
|
||||
// don't need to be used, or perhaps /should/ be used, are commented with
|
||||
// "concept requirements" (and maybe some more text). So grep like crazy
|
||||
// if you're looking for additional places to use these.
|
||||
|
||||
// Concept-checking code is off by default unless users turn it on via
|
||||
// configure options or editing c++config.h.
|
||||
|
||||
#ifndef _GLIBCPP_CONCEPT_CHECKS
|
||||
|
||||
#define __glibcpp_function_requires(...)
|
||||
#define __glibcpp_class_requires(_a,_b)
|
||||
#define __glibcpp_class_requires2(_a,_b,_c)
|
||||
#define __glibcpp_class_requires3(_a,_b,_c,_d)
|
||||
#define __glibcpp_class_requires4(_a,_b,_c,_d,_e)
|
||||
|
||||
#else // the checks are on
|
||||
|
||||
#include <bits/boost_concept_check.h>
|
||||
|
||||
// Note that the obvious and elegant approach of
|
||||
//
|
||||
//#define glibcpp_function_requires(C) \
|
||||
// boost::function_requires< boost::C >()
|
||||
//
|
||||
// won't work due to concept templates with more than one parameter, e.g.,
|
||||
// BinaryPredicateConcept. The preprocessor tries to split things up on
|
||||
// the commas in the template argument list. We can't use an inner pair of
|
||||
// parenthesis to hide the commas, because "boost::(Temp<Foo,Bar>)" isn't
|
||||
// a valid instantiation pattern. Thus, we steal a feature from C99.
|
||||
|
||||
#define __glibcpp_function_requires(...) \
|
||||
__gnu_cxx::__function_requires< __gnu_cxx::__VA_ARGS__ >();
|
||||
#define __glibcpp_class_requires(_a,_C) \
|
||||
_GLIBCPP_CLASS_REQUIRES(_a, __gnu_cxx, _C);
|
||||
#define __glibcpp_class_requires2(_a,_b,_C) \
|
||||
_GLIBCPP_CLASS_REQUIRES2(_a, _b, __gnu_cxx, _C);
|
||||
#define __glibcpp_class_requires3(_a,_b,_c,_C) \
|
||||
_GLIBCPP_CLASS_REQUIRES3(_a, _b, _c, __gnu_cxx, _C);
|
||||
#define __glibcpp_class_requires4(_a,_b,_c,_d,_C) \
|
||||
_GLIBCPP_CLASS_REQUIRES4(_a, _b, _c, _d, __gnu_cxx, _C);
|
||||
|
||||
#endif // enable/disable
|
||||
|
||||
#endif // _GLIBCPP_CONCEPT_CHECK
|
||||
300
TBE/MinGW/include/c++/3.2.3/bits/cpp_type_traits.h
Normal file
300
TBE/MinGW/include/c++/3.2.3/bits/cpp_type_traits.h
Normal file
@@ -0,0 +1,300 @@
|
||||
// The -*- C++ -*- type traits classes for internal use in libstdc++
|
||||
|
||||
// Copyright (C) 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
|
||||
|
||||
/** @file cpp_type_traits.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_CPP_TYPE_TRAITS_H
|
||||
#define _CPP_BITS_CPP_TYPE_TRAITS_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
//
|
||||
// This file provides some compile-time information about various types.
|
||||
// These representations were designed, on purpose, to be constant-expressions
|
||||
// and not types as found in <stl/bits/type_traits.h>. In particular, they
|
||||
// can be used in control structures and the optimizer hopefully will do
|
||||
// the obvious thing.
|
||||
//
|
||||
// Why integral expressions, and not functions nor types?
|
||||
// Firstly, these compile-time entities are used as template-arguments
|
||||
// so function return values won't work: We need compile-time entities.
|
||||
// We're left with types and constant integral expressions.
|
||||
// Secondly, from the point of view of ease of use, type-based compile-time
|
||||
// information is -not- *that* convenient. On has to write lots of
|
||||
// overloaded functions and to hope that the compiler will select the right
|
||||
// one. As a net effect, the overall structure isn't very clear at first
|
||||
// glance.
|
||||
// Thirdly, partial ordering and overload resolution (of function templates)
|
||||
// is highly costly in terms of compiler-resource. It is a Good Thing to
|
||||
// keep these resource consumption as least as possible.
|
||||
//
|
||||
// See valarray_array.h for a case use.
|
||||
//
|
||||
// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
|
||||
//
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _Tp>
|
||||
struct __is_void
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 0
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_void<void>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// Integer types
|
||||
//
|
||||
template<typename _Tp>
|
||||
struct __is_integer
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 0
|
||||
};
|
||||
};
|
||||
|
||||
// Thirteen specializations (yes there are eleven standard integer
|
||||
// types; 'long long' and 'unsigned long long' are supported as
|
||||
// extensions)
|
||||
template<>
|
||||
struct __is_integer<bool>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<char>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<signed char>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<unsigned char>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
# ifdef _GLIBCPP_USE_WCHAR_T
|
||||
template<>
|
||||
struct __is_integer<wchar_t>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
# endif
|
||||
|
||||
template<>
|
||||
struct __is_integer<short>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<unsigned short>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<int>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<unsigned int>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<long>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<unsigned long>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<long long>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_integer<unsigned long long>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// Floating point types
|
||||
//
|
||||
template<typename _Tp>
|
||||
struct __is_floating
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 0
|
||||
};
|
||||
};
|
||||
|
||||
// three specializations (float, double and 'long double')
|
||||
template<>
|
||||
struct __is_floating<float>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_floating<double>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __is_floating<long double>
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = 1
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// An arithmetic type is an integer type or a floating point type
|
||||
//
|
||||
template<typename _Tp>
|
||||
struct __is_arithmetic
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// A fundamental type is `void' or and arithmetic type
|
||||
//
|
||||
template<typename _Tp>
|
||||
struct __is_fundamental
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// For the immediate use, the following is a good approximation
|
||||
//
|
||||
template<typename _Tp>
|
||||
struct __is_pod
|
||||
{
|
||||
enum
|
||||
{
|
||||
_M_type = __is_fundamental<_Tp>::_M_type
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
|
||||
#endif //_CPP_BITS_CPP_TYPE_TRAITS_H
|
||||
123
TBE/MinGW/include/c++/3.2.3/bits/fpos.h
Normal file
123
TBE/MinGW/include/c++/3.2.3/bits/fpos.h
Normal file
@@ -0,0 +1,123 @@
|
||||
// File position object and stream types
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27 Input/output library
|
||||
//
|
||||
|
||||
/** @file fpos.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_FPOS_H
|
||||
#define _CPP_BITS_FPOS_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++io.h>
|
||||
#include <cwchar> // For mbstate_t.
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 27.4.1 Types
|
||||
|
||||
// 27.4.3 Template class fpos
|
||||
template<typename _StateT>
|
||||
class fpos
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef _StateT __state_type;
|
||||
|
||||
private:
|
||||
streamoff _M_off;
|
||||
__state_type _M_st;
|
||||
|
||||
public:
|
||||
__state_type
|
||||
state() const { return _M_st; }
|
||||
|
||||
void
|
||||
state(__state_type __st) { _M_st = __st; }
|
||||
|
||||
// NB: The standard defines only the implicit copy ctor and the
|
||||
// previous two members. The rest is a "conforming extension".
|
||||
fpos(): _M_off(streamoff()), _M_st(__state_type()) { }
|
||||
|
||||
fpos(streamoff __off, __state_type __st = __state_type())
|
||||
: _M_off(__off), _M_st(__st) { }
|
||||
|
||||
operator streamoff() const { return _M_off; }
|
||||
|
||||
fpos&
|
||||
operator+=(streamoff __off) { _M_off += __off; return *this; }
|
||||
|
||||
fpos&
|
||||
operator-=(streamoff __off) { _M_off -= __off; return *this; }
|
||||
|
||||
fpos
|
||||
operator+(streamoff __off)
|
||||
{
|
||||
fpos __t(*this);
|
||||
__t += __off;
|
||||
return __t;
|
||||
}
|
||||
|
||||
fpos
|
||||
operator-(streamoff __off)
|
||||
{
|
||||
fpos __t(*this);
|
||||
__t -= __off;
|
||||
return __t;
|
||||
}
|
||||
|
||||
bool
|
||||
operator==(const fpos& __pos) const
|
||||
{ return _M_off == __pos._M_off; }
|
||||
|
||||
bool
|
||||
operator!=(const fpos& __pos) const
|
||||
{ return _M_off != __pos._M_off; }
|
||||
|
||||
streamoff
|
||||
_M_position() const { return _M_off; }
|
||||
|
||||
void
|
||||
_M_position(streamoff __off) { _M_off = __off; }
|
||||
};
|
||||
|
||||
// 27.2, paragraph 10 about fpos/char_traits circularity
|
||||
typedef fpos<mbstate_t> streampos;
|
||||
# ifdef _GLIBCPP_USE_WCHAR_T
|
||||
typedef fpos<mbstate_t> wstreampos;
|
||||
# endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
510
TBE/MinGW/include/c++/3.2.3/bits/fstream.tcc
Normal file
510
TBE/MinGW/include/c++/3.2.3/bits/fstream.tcc
Normal file
@@ -0,0 +1,510 @@
|
||||
// File based streams -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27.8 File-based streams
|
||||
//
|
||||
|
||||
#ifndef _CPP_BITS_FSTREAM_TCC
|
||||
#define _CPP_BITS_FSTREAM_TCC 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
_M_allocate_internal_buffer()
|
||||
{
|
||||
if (!_M_buf && _M_buf_size_opt)
|
||||
{
|
||||
_M_buf_size = _M_buf_size_opt;
|
||||
|
||||
// Allocate internal buffer.
|
||||
_M_buf = new char_type[_M_buf_size];
|
||||
_M_buf_allocated = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Both close and setbuf need to deallocate internal buffers, if it exists.
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
_M_destroy_internal_buffer()
|
||||
{
|
||||
if (_M_buf_allocated)
|
||||
{
|
||||
delete [] _M_buf;
|
||||
_M_buf = NULL;
|
||||
_M_buf_allocated = false;
|
||||
this->setg(NULL, NULL, NULL);
|
||||
this->setp(NULL, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
basic_filebuf() : __streambuf_type(), _M_file(&_M_lock),
|
||||
_M_state_cur(__state_type()), _M_state_beg(__state_type()),
|
||||
_M_buf_allocated(false), _M_last_overflowed(false)
|
||||
{ _M_buf_unified = true; }
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
open(const char* __s, ios_base::openmode __mode)
|
||||
{
|
||||
__filebuf_type *__ret = NULL;
|
||||
if (!this->is_open())
|
||||
{
|
||||
_M_file.open(__s, __mode);
|
||||
if (this->is_open())
|
||||
{
|
||||
_M_allocate_internal_buffer();
|
||||
_M_mode = __mode;
|
||||
_M_set_indeterminate();
|
||||
|
||||
if ((__mode & ios_base::ate)
|
||||
&& this->seekoff(0, ios_base::end, __mode) < 0)
|
||||
{
|
||||
// 27.8.1.3,4
|
||||
this->close();
|
||||
return __ret;
|
||||
}
|
||||
|
||||
__ret = this;
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
close()
|
||||
{
|
||||
__filebuf_type *__ret = NULL;
|
||||
if (this->is_open())
|
||||
{
|
||||
const int_type __eof = traits_type::eof();
|
||||
bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
|
||||
if (__testput
|
||||
&& traits_type::eq_int_type(_M_really_overflow(__eof), __eof))
|
||||
return __ret;
|
||||
|
||||
// NB: Do this here so that re-opened filebufs will be cool...
|
||||
_M_mode = ios_base::openmode(0);
|
||||
_M_destroy_internal_buffer();
|
||||
_M_pback_destroy();
|
||||
|
||||
#if 0
|
||||
// XXX not done
|
||||
if (_M_last_overflowed)
|
||||
{
|
||||
_M_output_unshift();
|
||||
_M_really_overflow(__eof);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (_M_file.close())
|
||||
__ret = this;
|
||||
}
|
||||
|
||||
_M_last_overflowed = false;
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
streamsize
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
showmanyc()
|
||||
{
|
||||
streamsize __ret = -1;
|
||||
bool __testin = _M_mode & ios_base::in;
|
||||
|
||||
if (__testin && this->is_open())
|
||||
__ret = _M_in_end - _M_in_cur;
|
||||
_M_last_overflowed = false;
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::int_type
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
pbackfail(int_type __i)
|
||||
{
|
||||
int_type __ret = traits_type::eof();
|
||||
bool __testin = _M_mode & ios_base::in;
|
||||
|
||||
if (__testin)
|
||||
{
|
||||
bool __testpb = _M_in_beg < _M_in_cur;
|
||||
char_type __c = traits_type::to_char_type(__i);
|
||||
bool __testeof = traits_type::eq_int_type(__i, __ret);
|
||||
|
||||
if (__testpb)
|
||||
{
|
||||
bool __testout = _M_mode & ios_base::out;
|
||||
bool __testeq = traits_type::eq(__c, this->gptr()[-1]);
|
||||
|
||||
// Try to put back __c into input sequence in one of three ways.
|
||||
// Order these tests done in is unspecified by the standard.
|
||||
if (!__testeof && __testeq)
|
||||
{
|
||||
--_M_in_cur;
|
||||
if (__testout)
|
||||
--_M_out_cur;
|
||||
__ret = __i;
|
||||
}
|
||||
else if (__testeof)
|
||||
{
|
||||
--_M_in_cur;
|
||||
if (__testout)
|
||||
--_M_out_cur;
|
||||
__ret = traits_type::not_eof(__i);
|
||||
}
|
||||
else if (!__testeof)
|
||||
{
|
||||
--_M_in_cur;
|
||||
if (__testout)
|
||||
--_M_out_cur;
|
||||
_M_pback_create();
|
||||
*_M_in_cur = __c;
|
||||
__ret = __i;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// At the beginning of the buffer, need to make a
|
||||
// putback position available.
|
||||
// But the seek may fail (f.i., at the beginning of
|
||||
// a file, see libstdc++/9439) and in that case
|
||||
// we return traits_type::eof()
|
||||
if (this->seekoff(-1, ios_base::cur) >= 0)
|
||||
{
|
||||
this->underflow();
|
||||
if (!__testeof)
|
||||
{
|
||||
if (!traits_type::eq(__c, *this->_M_in_cur))
|
||||
{
|
||||
_M_pback_create();
|
||||
*this->_M_in_cur = __c;
|
||||
}
|
||||
__ret = __i;
|
||||
}
|
||||
else
|
||||
__ret = traits_type::not_eof(__i);
|
||||
}
|
||||
}
|
||||
}
|
||||
_M_last_overflowed = false;
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::int_type
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
overflow(int_type __c)
|
||||
{
|
||||
int_type __ret = traits_type::eof();
|
||||
bool __testput = _M_out_cur && _M_out_cur < _M_buf + _M_buf_size;
|
||||
bool __testout = _M_mode & ios_base::out;
|
||||
|
||||
if (__testout)
|
||||
{
|
||||
if (__testput)
|
||||
{
|
||||
*_M_out_cur = traits_type::to_char_type(__c);
|
||||
_M_out_cur_move(1);
|
||||
__ret = traits_type::not_eof(__c);
|
||||
}
|
||||
else
|
||||
__ret = this->_M_really_overflow(__c);
|
||||
}
|
||||
|
||||
_M_last_overflowed = false; // Set in _M_really_overflow, below.
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
_M_convert_to_external(_CharT* __ibuf, streamsize __ilen,
|
||||
streamsize& __elen, streamsize& __plen)
|
||||
{
|
||||
const locale __loc = this->getloc();
|
||||
const __codecvt_type& __cvt = use_facet<__codecvt_type>(__loc);
|
||||
|
||||
if (__cvt.always_noconv() && __ilen)
|
||||
{
|
||||
__elen += _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
|
||||
__plen += __ilen;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Worst-case number of external bytes needed.
|
||||
int __ext_multiplier = __cvt.encoding();
|
||||
if (__ext_multiplier == -1 || __ext_multiplier == 0)
|
||||
__ext_multiplier = sizeof(char_type);
|
||||
streamsize __blen = __ilen * __ext_multiplier;
|
||||
char* __buf = static_cast<char*>(__builtin_alloca(__blen));
|
||||
char* __bend;
|
||||
const char_type* __iend;
|
||||
__res_type __r = __cvt.out(_M_state_cur, __ibuf, __ibuf + __ilen,
|
||||
__iend, __buf, __buf + __blen, __bend);
|
||||
|
||||
if (__r == codecvt_base::ok || __r == codecvt_base::partial)
|
||||
__blen = __bend - __buf;
|
||||
// Similarly to the always_noconv case above.
|
||||
else if (__r == codecvt_base::noconv)
|
||||
{
|
||||
__buf = reinterpret_cast<char*>(__ibuf);
|
||||
__blen = __ilen;
|
||||
}
|
||||
// Result == error
|
||||
else
|
||||
__blen = 0;
|
||||
|
||||
if (__blen)
|
||||
{
|
||||
__elen += _M_file.xsputn(__buf, __blen);
|
||||
__plen += __blen;
|
||||
}
|
||||
|
||||
// Try once more for partial conversions.
|
||||
if (__r == codecvt_base::partial)
|
||||
{
|
||||
const char_type* __iresume = __iend;
|
||||
streamsize __rlen = _M_out_end - __iend;
|
||||
__r = __cvt.out(_M_state_cur, __iresume, __iresume + __rlen,
|
||||
__iend, __buf, __buf + __blen, __bend);
|
||||
if (__r != codecvt_base::error)
|
||||
__rlen = __bend - __buf;
|
||||
else
|
||||
__rlen = 0;
|
||||
if (__rlen)
|
||||
{
|
||||
__elen += _M_file.xsputn(__buf, __rlen);
|
||||
__plen += __rlen;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::int_type
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
_M_really_overflow(int_type __c)
|
||||
{
|
||||
int_type __ret = traits_type::eof();
|
||||
bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
|
||||
bool __testunbuffered = _M_file.is_open() && !_M_buf_size_opt;
|
||||
|
||||
if (__testput || __testunbuffered)
|
||||
{
|
||||
// Sizes of external and pending output.
|
||||
streamsize __elen = 0;
|
||||
streamsize __plen = 0;
|
||||
|
||||
// Need to restore current position. The position of the external
|
||||
// byte sequence (_M_file) corresponds to _M_filepos, and we need
|
||||
// to move it to _M_out_beg for the write.
|
||||
if (_M_filepos && _M_filepos != _M_out_beg)
|
||||
{
|
||||
off_type __off = _M_out_beg - _M_filepos;
|
||||
_M_file.seekoff(__off, ios_base::cur);
|
||||
}
|
||||
|
||||
// Convert internal buffer to external representation, output.
|
||||
// NB: In the unbuffered case, no internal buffer exists.
|
||||
if (!__testunbuffered)
|
||||
_M_convert_to_external(_M_out_beg, _M_out_end - _M_out_beg,
|
||||
__elen, __plen);
|
||||
|
||||
// Convert pending sequence to external representation, output.
|
||||
// If eof, then just attempt sync.
|
||||
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
||||
{
|
||||
char_type __pending = traits_type::to_char_type(__c);
|
||||
_M_convert_to_external(&__pending, 1, __elen, __plen);
|
||||
|
||||
// User code must flush when switching modes (thus don't sync).
|
||||
if (__elen == __plen)
|
||||
{
|
||||
_M_set_indeterminate();
|
||||
__ret = traits_type::not_eof(__c);
|
||||
}
|
||||
}
|
||||
else if (!_M_file.sync())
|
||||
{
|
||||
_M_set_indeterminate();
|
||||
__ret = traits_type::not_eof(__c);
|
||||
}
|
||||
}
|
||||
_M_last_overflowed = true;
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
setbuf(char_type* __s, streamsize __n)
|
||||
{
|
||||
if (!this->is_open() && __s == 0 && __n == 0)
|
||||
_M_buf_size_opt = 0;
|
||||
else if (__s && __n)
|
||||
{
|
||||
// This is implementation-defined behavior, and assumes
|
||||
// that an external char_type array of length (__s + __n)
|
||||
// exists and has been pre-allocated. If this is not the
|
||||
// case, things will quickly blow up.
|
||||
// Step 1: Destroy the current internal array.
|
||||
_M_destroy_internal_buffer();
|
||||
|
||||
// Step 2: Use the external array.
|
||||
_M_buf = __s;
|
||||
_M_buf_size_opt = _M_buf_size = __n;
|
||||
_M_set_indeterminate();
|
||||
}
|
||||
_M_last_overflowed = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::pos_type
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
|
||||
{
|
||||
pos_type __ret = pos_type(off_type(-1));
|
||||
bool __testin = (ios_base::in & _M_mode & __mode) != 0;
|
||||
bool __testout = (ios_base::out & _M_mode & __mode) != 0;
|
||||
|
||||
// Should probably do has_facet checks here.
|
||||
int __width = use_facet<__codecvt_type>(_M_buf_locale).encoding();
|
||||
if (__width < 0)
|
||||
__width = 0;
|
||||
bool __testfail = __off != 0 && __width <= 0;
|
||||
|
||||
if (this->is_open() && !__testfail && (__testin || __testout))
|
||||
{
|
||||
// Ditch any pback buffers to avoid confusion.
|
||||
_M_pback_destroy();
|
||||
|
||||
if (__way != ios_base::cur || __off != 0)
|
||||
{
|
||||
off_type __computed_off = __width * __off;
|
||||
|
||||
bool __testget = _M_in_cur && _M_in_beg < _M_in_end;
|
||||
bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
|
||||
// Sync the internal and external streams.
|
||||
// out
|
||||
if (__testput || _M_last_overflowed)
|
||||
{
|
||||
// Part one: update the output sequence.
|
||||
this->sync();
|
||||
// Part two: output unshift sequence.
|
||||
_M_output_unshift();
|
||||
}
|
||||
//in
|
||||
else if (__testget && __way == ios_base::cur)
|
||||
__computed_off += this->_M_in_cur - _M_filepos;
|
||||
|
||||
// Return pos_type(off_type(-1)) in case of failure.
|
||||
__ret = _M_file.seekoff(__computed_off, __way, __mode);
|
||||
_M_set_indeterminate();
|
||||
}
|
||||
// NB: Need to do this in case _M_file in indeterminate
|
||||
// state, ie _M_file._offset == -1
|
||||
else
|
||||
{
|
||||
pos_type __tmp =
|
||||
_M_file.seekoff(__off, ios_base::cur, __mode);
|
||||
if (__tmp >= 0)
|
||||
// Seek successful.
|
||||
__ret = __tmp +
|
||||
std::max(this->_M_out_cur, this->_M_in_cur) - _M_filepos;
|
||||
}
|
||||
}
|
||||
_M_last_overflowed = false;
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_filebuf<_CharT, _Traits>::pos_type
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
seekpos(pos_type __pos, ios_base::openmode __mode)
|
||||
{
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 171. Strange seekpos() semantics due to joint position
|
||||
return this->seekoff(off_type(__pos), ios_base::beg, __mode);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
_M_output_unshift()
|
||||
{ }
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
void
|
||||
basic_filebuf<_CharT, _Traits>::
|
||||
imbue(const locale& __loc)
|
||||
{
|
||||
bool __testbeg = gptr() == eback() && pptr() == pbase();
|
||||
|
||||
if (__testbeg && _M_buf_locale != __loc)
|
||||
_M_buf_locale = __loc;
|
||||
|
||||
// NB this may require the reconversion of previously
|
||||
// converted chars. This in turn may cause the reconstruction
|
||||
// of the original file. YIKES!!
|
||||
// XXX The part in the above comment is not done.
|
||||
_M_last_overflowed = false;
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_filebuf<char>;
|
||||
extern template class basic_ifstream<char>;
|
||||
extern template class basic_ofstream<char>;
|
||||
extern template class basic_fstream<char>;
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_filebuf<wchar_t>;
|
||||
extern template class basic_ifstream<wchar_t>;
|
||||
extern template class basic_ofstream<wchar_t>;
|
||||
extern template class basic_fstream<wchar_t>;
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
85
TBE/MinGW/include/c++/3.2.3/bits/functexcept.h
Normal file
85
TBE/MinGW/include/c++/3.2.3/bits/functexcept.h
Normal file
@@ -0,0 +1,85 @@
|
||||
// Function-Based Exception Support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 19.1 Exception classes
|
||||
//
|
||||
|
||||
#include <exception_defines.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Helper for exception objects in <except>
|
||||
void
|
||||
__throw_bad_exception(void);
|
||||
|
||||
// Helper for exception objects in <new>
|
||||
void
|
||||
__throw_bad_alloc(void);
|
||||
|
||||
// Helper for exception objects in <typeinfo>
|
||||
void
|
||||
__throw_bad_cast(void);
|
||||
|
||||
void
|
||||
__throw_bad_typeid(void);
|
||||
|
||||
// Helpers for exception objects in <stdexcept>
|
||||
void
|
||||
__throw_logic_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_domain_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_invalid_argument(const char* __s);
|
||||
|
||||
void
|
||||
__throw_length_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_out_of_range(const char* __s);
|
||||
|
||||
void
|
||||
__throw_runtime_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_range_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_overflow_error(const char* __s);
|
||||
|
||||
void
|
||||
__throw_underflow_error(const char* __s);
|
||||
|
||||
// Helpers for exception objects in basic_ios
|
||||
void
|
||||
__throw_ios_failure(const char* __s);
|
||||
} // namespace std
|
||||
|
||||
59
TBE/MinGW/include/c++/3.2.3/bits/generic_shadow.h
Normal file
59
TBE/MinGW/include/c++/3.2.3/bits/generic_shadow.h
Normal file
@@ -0,0 +1,59 @@
|
||||
// generic C header shadow file -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// This file is included by all the standard C <foo.h> headers
|
||||
// after defining _SHADOW_NAME.
|
||||
|
||||
#ifdef _IN_C_LEGACY_ /* sub-included by a C header */
|
||||
|
||||
// Get out of the "swamp."
|
||||
} // Close extern "C"
|
||||
} // Close namespace _C_legacy::
|
||||
|
||||
# undef _IN_C_LEGACY_
|
||||
# include _SHADOW_NAME
|
||||
|
||||
// Dive back into the "swamp."
|
||||
namespace _C_legacy {
|
||||
extern "C" {
|
||||
# define _IN_C_LEGACY_
|
||||
|
||||
#else /* not _IN_C_LEGACY_: directly included by user program */
|
||||
|
||||
# include _SHADOW_NAME
|
||||
|
||||
// Expose global C names, including non-standard ones, but shadow
|
||||
// some names and types with the std:: C++ version.
|
||||
|
||||
using namespace ::_C_legacy::_C_shadow;
|
||||
|
||||
#endif /* _IN_C_LEGACY_ */
|
||||
|
||||
|
||||
|
||||
124
TBE/MinGW/include/c++/3.2.3/bits/gslice.h
Normal file
124
TBE/MinGW/include/c++/3.2.3/bits/gslice.h
Normal file
@@ -0,0 +1,124 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file gslice.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_GSLICE_H
|
||||
#define _CPP_BITS_GSLICE_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std {
|
||||
|
||||
class gslice
|
||||
{
|
||||
public:
|
||||
gslice ();
|
||||
gslice (size_t, const valarray<size_t>&, const valarray<size_t>&);
|
||||
// XXX: the IS says the copy-ctor and copy-assignment operators are
|
||||
// synthetized by the compiler but they are just unsuitable
|
||||
// for a ref-counted semantic
|
||||
gslice(const gslice&);
|
||||
~gslice();
|
||||
|
||||
// XXX: See the note above.
|
||||
gslice& operator= (const gslice&);
|
||||
|
||||
size_t start () const;
|
||||
valarray<size_t> size () const;
|
||||
valarray<size_t> stride () const;
|
||||
|
||||
private:
|
||||
struct _Indexer {
|
||||
size_t _M_count;
|
||||
size_t _M_start;
|
||||
valarray<size_t> _M_size;
|
||||
valarray<size_t> _M_stride;
|
||||
valarray<size_t> _M_index;
|
||||
_Indexer(size_t, const valarray<size_t>&,
|
||||
const valarray<size_t>&);
|
||||
void _M_increment_use() { ++_M_count; }
|
||||
size_t _M_decrement_use() { return --_M_count; }
|
||||
};
|
||||
|
||||
_Indexer* _M_index;
|
||||
|
||||
template<typename _Tp> friend class valarray;
|
||||
};
|
||||
|
||||
inline size_t
|
||||
gslice::start () const
|
||||
{ return _M_index ? _M_index->_M_start : 0; }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::size () const
|
||||
{ return _M_index ? _M_index->_M_size : valarray<size_t>(); }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::stride () const
|
||||
{ return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
|
||||
|
||||
inline gslice::gslice () : _M_index(0) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s)
|
||||
: _M_index(new gslice::_Indexer(__o, __l, __s)) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
|
||||
{ if (_M_index) _M_index->_M_increment_use(); }
|
||||
|
||||
inline
|
||||
gslice::~gslice()
|
||||
{ if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
|
||||
|
||||
inline gslice&
|
||||
gslice::operator= (const gslice& __g)
|
||||
{
|
||||
if (__g._M_index) __g._M_index->_M_increment_use();
|
||||
if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index;
|
||||
_M_index = __g._M_index;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
} // std::
|
||||
|
||||
|
||||
#endif /* _CPP_BITS_GSLICE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
176
TBE/MinGW/include/c++/3.2.3/bits/gslice_array.h
Normal file
176
TBE/MinGW/include/c++/3.2.3/bits/gslice_array.h
Normal file
@@ -0,0 +1,176 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice_array class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file gslice_array.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_GSLICE_ARRAY
|
||||
#define _CPP_BITS_GSLICE_ARRAY 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std {
|
||||
|
||||
template<typename _Tp> class gslice_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<=(const valarray<_Tp>&) const;
|
||||
void operator>>=(const valarray<_Tp>&) const;
|
||||
void operator=(const _Tp&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_Tp>&) const;
|
||||
|
||||
private:
|
||||
_Array<_Tp> _M_array;
|
||||
const valarray<size_t>& _M_index;
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
|
||||
gslice_array (_Array<_Tp>, const valarray<size_t>&);
|
||||
|
||||
// this constructor needs to be implemented.
|
||||
gslice_array (const gslice_array&);
|
||||
|
||||
// not implemented
|
||||
gslice_array();
|
||||
gslice_array& operator= (const gslice_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (_Array<_Tp> __a,
|
||||
const valarray<size_t>& __i)
|
||||
: _M_array (__a), _M_index (__i) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a)
|
||||
: _M_array (__a._M_array), _M_index (__a._M_index) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Tp& __t)
|
||||
{
|
||||
__valarray_fill (_M_array, _Array<size_t>(_M_index),
|
||||
_M_index.size(), __t);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{
|
||||
__valarray_copy (_Array<_Tp> (__v), __v.size (),
|
||||
_M_array, _Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
template<class E>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
|
||||
{
|
||||
__valarray_copy (__e, _M_index.size(), _M_array,
|
||||
_Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), \
|
||||
_Array<_Tp> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class E> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator op##= (const _Expr<E, _Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), __e, \
|
||||
_M_index.size()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // std::
|
||||
|
||||
#endif /* _CPP_BITS_GSLICE_ARRAY */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
176
TBE/MinGW/include/c++/3.2.3/bits/indirect_array.h
Normal file
176
TBE/MinGW/include/c++/3.2.3/bits/indirect_array.h
Normal file
@@ -0,0 +1,176 @@
|
||||
// The template and inlines for the -*- C++ -*- indirect_array class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file indirect_array.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_INDIRECT_ARRAY_H
|
||||
#define _CPP_BITS_INDIRECT_ARRAY_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <class _Tp>
|
||||
class indirect_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
// XXX: This is a proposed resolution for DR-253.
|
||||
indirect_array& operator= (const indirect_array&);
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<= (const valarray<_Tp>&) const;
|
||||
void operator>>= (const valarray<_Tp>&) const;
|
||||
void operator= (const _Tp&);
|
||||
// ~indirect_array();
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom, _Tp>&) const;
|
||||
|
||||
private:
|
||||
indirect_array (const indirect_array&);
|
||||
indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
friend class gslice_array<_Tp>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<size_t> _M_index;
|
||||
const _Array<_Tp> _M_array;
|
||||
|
||||
// not implemented
|
||||
indirect_array ();
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
|
||||
: _M_sz (__a._M_sz), _M_index (__a._M_index),
|
||||
_M_array (__a._M_array) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
|
||||
_Array<size_t> __i)
|
||||
: _M_sz (__s), _M_index (__i), _M_array (__a) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>&
|
||||
indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
|
||||
{
|
||||
__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Tp& __t)
|
||||
{ __valarray_fill(_M_array, _M_index, _M_sz, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
|
||||
|
||||
template<typename _Tp>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class _Dom> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, __e, _M_sz); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // std::
|
||||
|
||||
#endif /* _CPP_BITS_INDIRECT_ARRAY_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
592
TBE/MinGW/include/c++/3.2.3/bits/ios_base.h
Normal file
592
TBE/MinGW/include/c++/3.2.3/bits/ios_base.h
Normal file
@@ -0,0 +1,592 @@
|
||||
// Iostreams base classes -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27.8 File-based streams
|
||||
//
|
||||
|
||||
/** @file ios_base.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_IOSBASE_H
|
||||
#define _CPP_BITS_IOSBASE_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/atomicity.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// The following definitions of bitmask types are enums, not ints,
|
||||
// as permitted (but not required) in the standard, in order to provide
|
||||
// better type safety in iostream calls. A side effect is that
|
||||
// expressions involving them are no longer compile-time constants.
|
||||
enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1L << 16 };
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
||||
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
||||
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
||||
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
||||
{ return __a = __a | __b; }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
||||
{ return __a = __a & __b; }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
||||
{ return __a = __a ^ __b; }
|
||||
|
||||
inline _Ios_Fmtflags
|
||||
operator~(_Ios_Fmtflags __a)
|
||||
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
|
||||
|
||||
|
||||
enum _Ios_Openmode { _M_ios_openmode_end = 1L << 16 };
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
|
||||
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
|
||||
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
|
||||
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
||||
{ return __a = __a | __b; }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
||||
{ return __a = __a & __b; }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
||||
{ return __a = __a ^ __b; }
|
||||
|
||||
inline _Ios_Openmode
|
||||
operator~(_Ios_Openmode __a)
|
||||
{ return _Ios_Openmode(~static_cast<int>(__a)); }
|
||||
|
||||
|
||||
enum _Ios_Iostate { _M_ios_iostate_end = 1L << 16 };
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
|
||||
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
|
||||
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
|
||||
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
||||
{ return __a = __a | __b; }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
||||
{ return __a = __a & __b; }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
||||
{ return __a = __a ^ __b; }
|
||||
|
||||
inline _Ios_Iostate
|
||||
operator~(_Ios_Iostate __a)
|
||||
{ return _Ios_Iostate(~static_cast<int>(__a)); }
|
||||
|
||||
enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 };
|
||||
|
||||
// 27.4.2 Class ios_base
|
||||
class ios_base
|
||||
{
|
||||
public:
|
||||
|
||||
// 27.4.2.1.1 Class ios_base::failure
|
||||
class failure : public exception
|
||||
{
|
||||
public:
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//48. Use of non-existent exception constructor
|
||||
explicit
|
||||
failure(const string& __str) throw();
|
||||
|
||||
// This declaration is not useless:
|
||||
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
|
||||
virtual
|
||||
~failure() throw();
|
||||
|
||||
virtual const char*
|
||||
what() const throw();
|
||||
|
||||
private:
|
||||
enum { _M_bufsize = 256 };
|
||||
char _M_name[_M_bufsize];
|
||||
#endif
|
||||
};
|
||||
|
||||
// 27.4.2.1.2 Type ios_base::fmtflags
|
||||
typedef _Ios_Fmtflags fmtflags;
|
||||
// 27.4.2.1.2 Type fmtflags
|
||||
static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);
|
||||
static const fmtflags dec = fmtflags(__ios_flags::_S_dec);
|
||||
static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);
|
||||
static const fmtflags hex = fmtflags(__ios_flags::_S_hex);
|
||||
static const fmtflags internal = fmtflags(__ios_flags::_S_internal);
|
||||
static const fmtflags left = fmtflags(__ios_flags::_S_left);
|
||||
static const fmtflags oct = fmtflags(__ios_flags::_S_oct);
|
||||
static const fmtflags right = fmtflags(__ios_flags::_S_right);
|
||||
static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);
|
||||
static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);
|
||||
static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);
|
||||
static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);
|
||||
static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);
|
||||
static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);
|
||||
static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);
|
||||
static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
|
||||
static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);
|
||||
static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);
|
||||
|
||||
// 27.4.2.1.3 Type ios_base::iostate
|
||||
typedef _Ios_Iostate iostate;
|
||||
static const iostate badbit = iostate(__ios_flags::_S_badbit);
|
||||
static const iostate eofbit = iostate(__ios_flags::_S_eofbit);
|
||||
static const iostate failbit = iostate(__ios_flags::_S_failbit);
|
||||
static const iostate goodbit = iostate(0);
|
||||
|
||||
// 27.4.2.1.4 Type openmode
|
||||
typedef _Ios_Openmode openmode;
|
||||
static const openmode app = openmode(__ios_flags::_S_app);
|
||||
static const openmode ate = openmode(__ios_flags::_S_ate);
|
||||
static const openmode binary = openmode(__ios_flags::_S_bin);
|
||||
static const openmode in = openmode(__ios_flags::_S_in);
|
||||
static const openmode out = openmode(__ios_flags::_S_out);
|
||||
static const openmode trunc = openmode(__ios_flags::_S_trunc);
|
||||
|
||||
// 27.4.2.1.5 Type seekdir
|
||||
typedef _Ios_Seekdir seekdir;
|
||||
static const seekdir beg = seekdir(0);
|
||||
static const seekdir cur = seekdir(SEEK_CUR);
|
||||
static const seekdir end = seekdir(SEEK_END);
|
||||
|
||||
#ifdef _GLIBCPP_DEPRECATED
|
||||
typedef int io_state;
|
||||
typedef int open_mode;
|
||||
typedef int seek_dir;
|
||||
|
||||
typedef std::streampos streampos;
|
||||
typedef std::streamoff streamoff;
|
||||
#endif
|
||||
|
||||
// Callbacks;
|
||||
enum event
|
||||
{
|
||||
erase_event,
|
||||
imbue_event,
|
||||
copyfmt_event
|
||||
};
|
||||
|
||||
typedef void (*event_callback) (event, ios_base&, int);
|
||||
|
||||
void
|
||||
register_callback(event_callback __fn, int __index);
|
||||
|
||||
protected:
|
||||
// Data Members
|
||||
streamsize _M_precision;
|
||||
streamsize _M_width;
|
||||
fmtflags _M_flags;
|
||||
iostate _M_exception;
|
||||
iostate _M_streambuf_state;
|
||||
|
||||
// 27.4.2.6 Members for callbacks
|
||||
// 27.4.2.6 ios_base callbacks
|
||||
struct _Callback_list
|
||||
{
|
||||
// Data Members
|
||||
_Callback_list* _M_next;
|
||||
ios_base::event_callback _M_fn;
|
||||
int _M_index;
|
||||
_Atomic_word _M_refcount; // 0 means one reference.
|
||||
|
||||
_Callback_list(ios_base::event_callback __fn, int __index,
|
||||
_Callback_list* __cb)
|
||||
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
|
||||
|
||||
void
|
||||
_M_add_reference() { __atomic_add(&_M_refcount, 1); }
|
||||
|
||||
// 0 => OK to delete.
|
||||
int
|
||||
_M_remove_reference() { return __exchange_and_add(&_M_refcount, -1); }
|
||||
};
|
||||
|
||||
_Callback_list* _M_callbacks;
|
||||
|
||||
void
|
||||
_M_call_callbacks(event __ev) throw();
|
||||
|
||||
void
|
||||
_M_dispose_callbacks(void);
|
||||
|
||||
// 27.4.2.5 Members for iword/pword storage
|
||||
struct _Words
|
||||
{
|
||||
void* _M_pword;
|
||||
long _M_iword;
|
||||
_Words() : _M_pword(0), _M_iword(0) { }
|
||||
};
|
||||
|
||||
// Only for failed iword/pword calls.
|
||||
_Words _M_word_zero;
|
||||
|
||||
// Guaranteed storage.
|
||||
static const int _S_local_word_size = 8;
|
||||
_Words _M_local_word[_S_local_word_size];
|
||||
|
||||
// Allocated storage.
|
||||
int _M_word_size;
|
||||
_Words* _M_word;
|
||||
|
||||
_Words&
|
||||
_M_grow_words(int __index);
|
||||
|
||||
// Members for locale and locale caching.
|
||||
locale _M_ios_locale;
|
||||
|
||||
void
|
||||
_M_init();
|
||||
|
||||
public:
|
||||
|
||||
// 27.4.2.1.6 Class ios_base::Init
|
||||
// Used to initialize standard streams. In theory, g++ could use
|
||||
// -finit-priority to order this stuff correctly without going
|
||||
// through these machinations.
|
||||
class Init
|
||||
{
|
||||
friend class ios_base;
|
||||
public:
|
||||
Init();
|
||||
~Init();
|
||||
|
||||
static void
|
||||
_S_ios_create(bool __sync);
|
||||
|
||||
static void
|
||||
_S_ios_destroy();
|
||||
|
||||
private:
|
||||
static int _S_ios_base_init;
|
||||
static bool _S_synced_with_stdio;
|
||||
};
|
||||
|
||||
// Fmtflags state:
|
||||
inline fmtflags
|
||||
flags() const { return _M_flags; }
|
||||
|
||||
inline fmtflags
|
||||
flags(fmtflags __fmtfl)
|
||||
{
|
||||
fmtflags __old = _M_flags;
|
||||
_M_flags = __fmtfl;
|
||||
return __old;
|
||||
}
|
||||
|
||||
inline fmtflags
|
||||
setf(fmtflags __fmtfl)
|
||||
{
|
||||
fmtflags __old = _M_flags;
|
||||
_M_flags |= __fmtfl;
|
||||
return __old;
|
||||
}
|
||||
|
||||
inline fmtflags
|
||||
setf(fmtflags __fmtfl, fmtflags __mask)
|
||||
{
|
||||
fmtflags __old = _M_flags;
|
||||
_M_flags &= ~__mask;
|
||||
_M_flags |= (__fmtfl & __mask);
|
||||
return __old;
|
||||
}
|
||||
|
||||
inline void
|
||||
unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
|
||||
|
||||
inline streamsize
|
||||
precision() const { return _M_precision; }
|
||||
|
||||
inline streamsize
|
||||
precision(streamsize __prec)
|
||||
{
|
||||
streamsize __old = _M_precision;
|
||||
_M_precision = __prec;
|
||||
return __old;
|
||||
}
|
||||
|
||||
inline streamsize
|
||||
width() const { return _M_width; }
|
||||
|
||||
inline streamsize
|
||||
width(streamsize __wide)
|
||||
{
|
||||
streamsize __old = _M_width;
|
||||
_M_width = __wide;
|
||||
return __old;
|
||||
}
|
||||
|
||||
static bool
|
||||
sync_with_stdio(bool __sync = true);
|
||||
|
||||
// Locales:
|
||||
locale
|
||||
imbue(const locale& __loc);
|
||||
|
||||
inline locale
|
||||
getloc() const { return _M_ios_locale; }
|
||||
|
||||
// Storage:
|
||||
static int
|
||||
xalloc() throw();
|
||||
|
||||
inline long&
|
||||
iword(int __ix)
|
||||
{
|
||||
_Words& __word = (__ix < _M_word_size)
|
||||
? _M_word[__ix] : _M_grow_words(__ix);
|
||||
return __word._M_iword;
|
||||
}
|
||||
|
||||
inline void*&
|
||||
pword(int __ix)
|
||||
{
|
||||
_Words& __word = (__ix < _M_word_size)
|
||||
? _M_word[__ix] : _M_grow_words(__ix);
|
||||
return __word._M_pword;
|
||||
}
|
||||
|
||||
// Destructor
|
||||
~ios_base();
|
||||
|
||||
protected:
|
||||
ios_base();
|
||||
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//50. Copy constructor and assignment operator of ios_base
|
||||
private:
|
||||
ios_base(const ios_base&);
|
||||
|
||||
ios_base&
|
||||
operator=(const ios_base&);
|
||||
#endif
|
||||
};
|
||||
|
||||
// 27.4.5.1 fmtflags manipulators:
|
||||
inline ios_base&
|
||||
boolalpha(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::boolalpha);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
noboolalpha(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::boolalpha);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
showbase(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::showbase);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
noshowbase(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::showbase);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
showpoint(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::showpoint);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
noshowpoint(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::showpoint);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
showpos(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::showpos);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
noshowpos(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::showpos);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
skipws(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::skipws);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
noskipws(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::skipws);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
uppercase(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::uppercase);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
nouppercase(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::uppercase);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
unitbuf(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::unitbuf);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
nounitbuf(ios_base& __base)
|
||||
{
|
||||
__base.unsetf(ios_base::unitbuf);
|
||||
return __base;
|
||||
}
|
||||
|
||||
// 27.4.5.2 adjustfield anipulators:
|
||||
inline ios_base&
|
||||
internal(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::internal, ios_base::adjustfield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
left(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::left, ios_base::adjustfield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
right(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::right, ios_base::adjustfield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
// 27.4.5.3 basefield anipulators:
|
||||
inline ios_base&
|
||||
dec(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::dec, ios_base::basefield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
hex(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::hex, ios_base::basefield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
oct(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::oct, ios_base::basefield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
// 27.4.5.4 floatfield anipulators:
|
||||
inline ios_base&
|
||||
fixed(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::fixed, ios_base::floatfield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
inline ios_base&
|
||||
scientific(ios_base& __base)
|
||||
{
|
||||
__base.setf(ios_base::scientific, ios_base::floatfield);
|
||||
return __base;
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_IOSBASE_H */
|
||||
|
||||
1207
TBE/MinGW/include/c++/3.2.3/bits/istream.tcc
Normal file
1207
TBE/MinGW/include/c++/3.2.3/bits/istream.tcc
Normal file
File diff suppressed because it is too large
Load Diff
1810
TBE/MinGW/include/c++/3.2.3/bits/locale_facets.h
Normal file
1810
TBE/MinGW/include/c++/3.2.3/bits/locale_facets.h
Normal file
File diff suppressed because it is too large
Load Diff
2471
TBE/MinGW/include/c++/3.2.3/bits/locale_facets.tcc
Normal file
2471
TBE/MinGW/include/c++/3.2.3/bits/locale_facets.tcc
Normal file
File diff suppressed because it is too large
Load Diff
508
TBE/MinGW/include/c++/3.2.3/bits/localefwd.h
Normal file
508
TBE/MinGW/include/c++/3.2.3/bits/localefwd.h
Normal file
@@ -0,0 +1,508 @@
|
||||
// Locale support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 22.1 Locales
|
||||
//
|
||||
|
||||
/** @file localefwd.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_LOCCORE_H
|
||||
#define _CPP_BITS_LOCCORE_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++config.h>
|
||||
#include <bits/c++locale.h> // Defines __c_locale, config-specific includes
|
||||
#include <climits> // For CHAR_BIT
|
||||
#include <cctype> // For isspace, etc.
|
||||
#include <string> // For string.
|
||||
#include <bits/functexcept.h>
|
||||
#include <bits/atomicity.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 22.1.1 Locale
|
||||
class locale;
|
||||
|
||||
// 22.1.3 Convenience interfaces
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isspace(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isprint(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
iscntrl(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isupper(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
islower(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isalpha(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isdigit(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
ispunct(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isxdigit(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isalnum(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline bool
|
||||
isgraph(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline _CharT
|
||||
toupper(_CharT, const locale&);
|
||||
|
||||
template<typename _CharT>
|
||||
inline _CharT
|
||||
tolower(_CharT, const locale&);
|
||||
|
||||
|
||||
// 22.2.1 and 22.2.1.3 ctype
|
||||
class ctype_base;
|
||||
template<typename _CharT>
|
||||
class ctype;
|
||||
template<> class ctype<char>;
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
template<> class ctype<wchar_t>;
|
||||
#endif
|
||||
template<typename _CharT>
|
||||
class ctype_byname;
|
||||
// NB: Specialized for char and wchar_t in locale_facets.h.
|
||||
|
||||
class codecvt_base;
|
||||
class __enc_traits;
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
class codecvt;
|
||||
template<> class codecvt<char, char, mbstate_t>;
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
template<> class codecvt<wchar_t, char, mbstate_t>;
|
||||
#endif
|
||||
template<typename _InternT, typename _ExternT, typename _StateT>
|
||||
class codecvt_byname;
|
||||
|
||||
// 22.2.2 and 22.2.3 numeric
|
||||
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
||||
class num_get;
|
||||
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
||||
class num_put;
|
||||
template<typename _CharT> class numpunct;
|
||||
template<typename _CharT> class numpunct_byname;
|
||||
|
||||
// 22.2.4 collation
|
||||
template<typename _CharT>
|
||||
class collate;
|
||||
template<typename _CharT> class
|
||||
collate_byname;
|
||||
|
||||
// 22.2.5 date and time
|
||||
class time_base;
|
||||
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
||||
class time_get;
|
||||
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
||||
class time_get_byname;
|
||||
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
||||
class time_put;
|
||||
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
||||
class time_put_byname;
|
||||
|
||||
// 22.2.6 money
|
||||
class money_base;
|
||||
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
||||
class money_get;
|
||||
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
||||
class money_put;
|
||||
template<typename _CharT, bool _Intl = false>
|
||||
class moneypunct;
|
||||
template<typename _CharT, bool _Intl = false>
|
||||
class moneypunct_byname;
|
||||
|
||||
// 22.2.7 message retrieval
|
||||
class messages_base;
|
||||
template<typename _CharT>
|
||||
class messages;
|
||||
template<typename _CharT>
|
||||
class messages_byname;
|
||||
|
||||
// 22.1.1 Class locale
|
||||
class locale
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef unsigned int category;
|
||||
|
||||
// Forward decls and friends:
|
||||
class facet;
|
||||
class id;
|
||||
class _Impl;
|
||||
|
||||
friend class facet;
|
||||
friend class _Impl;
|
||||
|
||||
template<typename _Facet>
|
||||
friend const _Facet&
|
||||
use_facet(const locale&);
|
||||
|
||||
template<typename _Facet>
|
||||
friend bool
|
||||
has_facet(const locale&) throw();
|
||||
|
||||
// Category values:
|
||||
// NB: Order must match _S_facet_categories definition in locale.cc
|
||||
static const category none = 0;
|
||||
static const category ctype = 1L << 0;
|
||||
static const category numeric = 1L << 1;
|
||||
static const category collate = 1L << 2;
|
||||
static const category time = 1L << 3;
|
||||
static const category monetary = 1L << 4;
|
||||
static const category messages = 1L << 5;
|
||||
static const category all = (ctype | numeric | collate |
|
||||
time | monetary | messages);
|
||||
|
||||
// Construct/copy/destroy:
|
||||
locale() throw();
|
||||
|
||||
locale(const locale& __other) throw();
|
||||
|
||||
explicit
|
||||
locale(const char* __s);
|
||||
|
||||
locale(const locale& __base, const char* __s, category __cat);
|
||||
|
||||
locale(const locale& __base, const locale& __add, category __cat);
|
||||
|
||||
template<typename _Facet>
|
||||
locale(const locale& __other, _Facet* __f);
|
||||
|
||||
~locale() throw();
|
||||
|
||||
const locale&
|
||||
operator=(const locale& __other) throw();
|
||||
|
||||
template<typename _Facet>
|
||||
locale
|
||||
combine(const locale& __other) const;
|
||||
|
||||
// Locale operations:
|
||||
string
|
||||
name() const;
|
||||
|
||||
bool
|
||||
operator==(const locale& __other) const throw ();
|
||||
|
||||
inline bool
|
||||
operator!=(const locale& __other) const throw ()
|
||||
{ return !(this->operator==(__other)); }
|
||||
|
||||
template<typename _Char, typename _Traits, typename _Alloc>
|
||||
bool
|
||||
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
|
||||
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
|
||||
|
||||
// Global locale objects:
|
||||
static locale
|
||||
global(const locale&);
|
||||
|
||||
static const locale&
|
||||
classic();
|
||||
|
||||
private:
|
||||
// The (shared) implementation
|
||||
_Impl* _M_impl;
|
||||
|
||||
// The "C" reference locale
|
||||
static _Impl* _S_classic;
|
||||
|
||||
// Current global locale
|
||||
static _Impl* _S_global;
|
||||
|
||||
// Number of standard categories. For C++, these categories are
|
||||
// collate, ctype, monetary, numeric, time, and messages. These
|
||||
// directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
|
||||
// LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
|
||||
// 1003.1-2001) specifies LC_MESSAGES.
|
||||
static const size_t _S_categories_size = 6;
|
||||
|
||||
// In addition to the standard categories, the underlying
|
||||
// operating system is allowed to define extra LC_*
|
||||
// macros. For GNU systems, the following are also valid:
|
||||
// LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
|
||||
// and LC_IDENTIFICATION.
|
||||
static const size_t _S_extra_categories_size = _GLIBCPP_NUM_CATEGORIES;
|
||||
|
||||
// Names of underlying locale categories.
|
||||
// NB: locale::global() has to know how to modify all the
|
||||
// underlying categories, not just the ones required by the C++
|
||||
// standard.
|
||||
static const char* _S_categories[_S_categories_size
|
||||
+ _S_extra_categories_size];
|
||||
|
||||
explicit
|
||||
locale(_Impl*) throw();
|
||||
|
||||
static inline void
|
||||
_S_initialize()
|
||||
{
|
||||
if (!_S_classic)
|
||||
classic();
|
||||
}
|
||||
|
||||
static category
|
||||
_S_normalize_category(category);
|
||||
|
||||
void
|
||||
_M_coalesce(const locale& __base, const locale& __add, category __cat);
|
||||
};
|
||||
|
||||
|
||||
// Implementation object for locale
|
||||
class locale::_Impl
|
||||
{
|
||||
public:
|
||||
// Friends.
|
||||
friend class locale;
|
||||
friend class locale::facet;
|
||||
|
||||
template<typename _Facet>
|
||||
friend const _Facet&
|
||||
use_facet(const locale&);
|
||||
|
||||
template<typename _Facet>
|
||||
friend bool
|
||||
has_facet(const locale&) throw();
|
||||
|
||||
private:
|
||||
// Data Members.
|
||||
_Atomic_word _M_references;
|
||||
facet** _M_facets;
|
||||
size_t _M_facets_size;
|
||||
|
||||
char* _M_names[_S_categories_size
|
||||
+ _S_extra_categories_size];
|
||||
static const locale::id* const _S_id_ctype[];
|
||||
static const locale::id* const _S_id_numeric[];
|
||||
static const locale::id* const _S_id_collate[];
|
||||
static const locale::id* const _S_id_time[];
|
||||
static const locale::id* const _S_id_monetary[];
|
||||
static const locale::id* const _S_id_messages[];
|
||||
static const locale::id* const* const _S_facet_categories[];
|
||||
|
||||
inline void
|
||||
_M_add_reference() throw()
|
||||
{ __atomic_add(&_M_references, 1); }
|
||||
|
||||
inline void
|
||||
_M_remove_reference() throw()
|
||||
{
|
||||
if (__exchange_and_add(&_M_references, -1) == 1)
|
||||
{
|
||||
try
|
||||
{ delete this; }
|
||||
catch(...)
|
||||
{ }
|
||||
}
|
||||
}
|
||||
|
||||
_Impl(const _Impl&, size_t);
|
||||
_Impl(const char*, size_t);
|
||||
_Impl(facet**, size_t, bool);
|
||||
|
||||
~_Impl() throw();
|
||||
|
||||
_Impl(const _Impl&); // Not defined.
|
||||
|
||||
void
|
||||
operator=(const _Impl&); // Not defined.
|
||||
|
||||
inline bool
|
||||
_M_check_same_name()
|
||||
{
|
||||
bool __ret = true;
|
||||
for (size_t __i = 0;
|
||||
__ret && __i < _S_categories_size + _S_extra_categories_size - 1;
|
||||
++__i)
|
||||
__ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0);
|
||||
return __ret;
|
||||
}
|
||||
|
||||
void
|
||||
_M_replace_categories(const _Impl*, category);
|
||||
|
||||
void
|
||||
_M_replace_category(const _Impl*, const locale::id* const*);
|
||||
|
||||
void
|
||||
_M_replace_facet(const _Impl*, const locale::id*);
|
||||
|
||||
void
|
||||
_M_install_facet(const locale::id*, facet*);
|
||||
|
||||
template<typename _Facet>
|
||||
inline void
|
||||
_M_init_facet(_Facet* __facet)
|
||||
{ _M_install_facet(&_Facet::id, __facet); }
|
||||
};
|
||||
|
||||
template<typename _Facet>
|
||||
locale::locale(const locale& __other, _Facet* __f)
|
||||
{
|
||||
_M_impl = new _Impl(*__other._M_impl, 1);
|
||||
_M_impl->_M_install_facet(&_Facet::id, __f);
|
||||
for (size_t __i = 0;
|
||||
__i < _S_categories_size + _S_extra_categories_size; ++__i)
|
||||
{
|
||||
delete [] _M_impl->_M_names[__i];
|
||||
char* __new = new char[2];
|
||||
strcpy(__new, "*");
|
||||
_M_impl->_M_names[__i] = __new;
|
||||
}
|
||||
}
|
||||
|
||||
// 22.1.1.1.2 Class locale::facet
|
||||
class locale::facet
|
||||
{
|
||||
private:
|
||||
friend class locale;
|
||||
friend class locale::_Impl;
|
||||
|
||||
_Atomic_word _M_references;
|
||||
|
||||
protected:
|
||||
// Contains data from the underlying "C" library for for the
|
||||
// classic locale.
|
||||
static __c_locale _S_c_locale;
|
||||
|
||||
// String literal for the name of the classic locale.
|
||||
static char _S_c_name[2];
|
||||
|
||||
explicit
|
||||
facet(size_t __refs = 0) throw();
|
||||
|
||||
virtual
|
||||
~facet();
|
||||
|
||||
static void
|
||||
_S_create_c_locale(__c_locale& __cloc, const char* __s,
|
||||
__c_locale __old = 0);
|
||||
|
||||
static __c_locale
|
||||
_S_clone_c_locale(__c_locale& __cloc);
|
||||
|
||||
static void
|
||||
_S_destroy_c_locale(__c_locale& __cloc);
|
||||
|
||||
private:
|
||||
void
|
||||
_M_add_reference() throw();
|
||||
|
||||
void
|
||||
_M_remove_reference() throw();
|
||||
|
||||
facet(const facet&); // Not defined.
|
||||
|
||||
void
|
||||
operator=(const facet&); // Not defined.
|
||||
};
|
||||
|
||||
|
||||
// 22.1.1.1.3 Class locale::id
|
||||
class locale::id
|
||||
{
|
||||
private:
|
||||
friend class locale;
|
||||
friend class locale::_Impl;
|
||||
template<typename _Facet>
|
||||
friend const _Facet&
|
||||
use_facet(const locale&);
|
||||
template<typename _Facet>
|
||||
friend bool
|
||||
has_facet(const locale&) throw ();
|
||||
|
||||
// NB: There is no accessor for _M_index because it may be used
|
||||
// before the constructor is run; the effect of calling a member
|
||||
// function (even an inline) would be undefined.
|
||||
mutable size_t _M_index;
|
||||
|
||||
// Last id number assigned.
|
||||
static _Atomic_word _S_highwater;
|
||||
|
||||
void
|
||||
operator=(const id&); // Not defined.
|
||||
|
||||
id(const id&); // Not defined.
|
||||
|
||||
public:
|
||||
// NB: This class is always a static data member, and thus can be
|
||||
// counted on to be zero-initialized.
|
||||
id();
|
||||
|
||||
inline size_t
|
||||
_M_id() const
|
||||
{
|
||||
if (!_M_index)
|
||||
_M_index = 1 + __exchange_and_add(&_S_highwater, 1);
|
||||
return _M_index - 1;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Facet>
|
||||
const _Facet&
|
||||
use_facet(const locale& __loc);
|
||||
|
||||
template<typename _Facet>
|
||||
bool
|
||||
has_facet(const locale& __loc) throw();
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
167
TBE/MinGW/include/c++/3.2.3/bits/mask_array.h
Normal file
167
TBE/MinGW/include/c++/3.2.3/bits/mask_array.h
Normal file
@@ -0,0 +1,167 @@
|
||||
// The template and inlines for the -*- C++ -*- mask_array class.
|
||||
|
||||
// Copyright (C) 1997-2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file mask_array.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_MASK_ARRAY_H
|
||||
#define _CPP_BITS_MASK_ARRAY_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std {
|
||||
|
||||
template <class _Tp> class mask_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<=(const valarray<_Tp>&) const;
|
||||
void operator>>=(const valarray<_Tp>&) const;
|
||||
void operator= (const _Tp&);
|
||||
|
||||
// ~mask_array ();
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<=(const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>=(const _Expr<_Dom,_Tp>&) const;
|
||||
|
||||
private:
|
||||
mask_array (_Array<_Tp>, size_t, _Array<bool>);
|
||||
friend class valarray<_Tp>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<bool> _M_mask;
|
||||
const _Array<_Tp> _M_array;
|
||||
|
||||
mask_array (const mask_array&);
|
||||
|
||||
// not implemented
|
||||
mask_array ();
|
||||
mask_array& operator= (const mask_array&);
|
||||
};
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline mask_array<_Tp>::mask_array (const mask_array<_Tp>& a)
|
||||
: _M_sz (a._M_sz), _M_mask (a._M_mask), _M_array (a._M_array) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
mask_array<_Tp>::mask_array (_Array<_Tp> __a, size_t __s, _Array<bool> __m)
|
||||
: _M_sz (__s), _M_mask (__m), _M_array (__a) {}
|
||||
|
||||
// template<typename _Tp>
|
||||
// inline mask_array<_Tp>::~mask_array () {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
mask_array<_Tp>::operator= (const _Tp& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_mask, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
mask_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{ __valarray_copy (_Array<_Tp> (__v), __v.size (), _M_array, _M_mask); }
|
||||
|
||||
template<typename _Tp>
|
||||
template<class E>
|
||||
inline void
|
||||
mask_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
|
||||
{ __valarray_copy (__e, __e.size (), _M_array, _M_mask); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
mask_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, \
|
||||
_Array<_Tp> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class E> \
|
||||
inline void \
|
||||
mask_array<_Tp>::operator op##= (const _Expr<E, _Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, __e, __e.size ()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // std::
|
||||
|
||||
#endif /* _CPP_BITS_MASK_ARRAY_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
713
TBE/MinGW/include/c++/3.2.3/bits/ostream.tcc
Normal file
713
TBE/MinGW/include/c++/3.2.3/bits/ostream.tcc
Normal file
@@ -0,0 +1,713 @@
|
||||
// ostream classes -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27.6.2 Output streams
|
||||
//
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <locale>
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>::sentry::
|
||||
sentry(basic_ostream<_CharT,_Traits>& __os)
|
||||
: _M_ok(__os.good()), _M_os(__os)
|
||||
{
|
||||
// XXX MT
|
||||
if (_M_ok && __os.tie())
|
||||
__os.tie()->flush();
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::
|
||||
operator<<(__ostream_type& (*__pf)(__ostream_type&))
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{ __pf(*this); }
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.2.5.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::
|
||||
operator<<(__ios_type& (*__pf)(__ios_type&))
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{ __pf(*this); }
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.2.5.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::
|
||||
operator<<(ios_base& (*__pf)(ios_base&))
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{ __pf(*this); }
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.2.5.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(__streambuf_type* __sbin)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb && __sbin)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!__copy_streambufs(*this, __sbin, this->rdbuf()))
|
||||
this->setstate(ios_base::failbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.2.5.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
else if (!__sbin)
|
||||
this->setstate(ios_base::badbit);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(bool __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(long __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
char_type __c = this->fill();
|
||||
ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
{
|
||||
bool __b = false;
|
||||
if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
|
||||
{
|
||||
unsigned long __l = static_cast<unsigned long>(__n);
|
||||
__b = _M_fnumput->put(*this, *this, __c, __l).failed();
|
||||
}
|
||||
else
|
||||
__b = _M_fnumput->put(*this, *this, __c, __n).failed();
|
||||
if (__b)
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef _GLIBCPP_USE_LONG_LONG
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(long long __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
char_type __c = this->fill();
|
||||
ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
{
|
||||
bool __b = false;
|
||||
if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
|
||||
{
|
||||
unsigned long long __l;
|
||||
__l = static_cast<unsigned long long>(__n);
|
||||
__b = _M_fnumput->put(*this, *this, __c, __l).failed();
|
||||
}
|
||||
else
|
||||
__b = _M_fnumput->put(*this, *this, __c, __n).failed();
|
||||
if (__b)
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(double __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(long double __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_M_check_facet(_M_fnumput))
|
||||
if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
this->setstate(ios_base::badbit);
|
||||
if ((this->exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::put(char_type __c)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
int_type __put = rdbuf()->sputc(__c);
|
||||
if (traits_type::eq_int_type(__put, traits_type::eof()))
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::write(const _CharT* __s, streamsize __n)
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
streamsize __put = this->rdbuf()->sputn(__s, __n);
|
||||
if ( __put != __n)
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::flush()
|
||||
{
|
||||
sentry __cerb(*this);
|
||||
if (__cerb)
|
||||
{
|
||||
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
|
||||
this->setstate(ios_base::badbit);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_ostream<_CharT, _Traits>::pos_type
|
||||
basic_ostream<_CharT, _Traits>::tellp()
|
||||
{
|
||||
pos_type __ret = pos_type(-1);
|
||||
if (!this->fail())
|
||||
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
|
||||
return __ret;
|
||||
}
|
||||
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
|
||||
{
|
||||
if (!this->fail())
|
||||
{
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 136. seekp, seekg setting wrong streams?
|
||||
pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::out);
|
||||
|
||||
// 129. Need error indication from seekp() and seekg()
|
||||
if (__err == pos_type(off_type(-1)))
|
||||
this->setstate(ios_base::failbit);
|
||||
#endif
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
basic_ostream<_CharT, _Traits>::
|
||||
seekp(off_type __off, ios_base::seekdir __d)
|
||||
{
|
||||
if (!this->fail())
|
||||
{
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 136. seekp, seekg setting wrong streams?
|
||||
pos_type __err = this->rdbuf()->pubseekoff(__off, __d,
|
||||
ios_base::out);
|
||||
|
||||
// 129. Need error indication from seekp() and seekg()
|
||||
if (__err == pos_type(off_type(-1)))
|
||||
this->setstate(ios_base::failbit);
|
||||
#endif
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// 27.6.2.5.4 Character inserters.
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
|
||||
{
|
||||
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
streamsize __w = __out.width();
|
||||
_CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__w + 1)));
|
||||
__pads[0] = __c;
|
||||
streamsize __len = 1;
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
|
||||
&__c, __w, __len, false);
|
||||
__len = __w;
|
||||
}
|
||||
__out.write(__pads, __len);
|
||||
__out.width(0);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
__out.setstate(ios_base::badbit);
|
||||
if ((__out.exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return __out;
|
||||
}
|
||||
|
||||
// Specializations.
|
||||
template <class _Traits>
|
||||
basic_ostream<char, _Traits>&
|
||||
operator<<(basic_ostream<char, _Traits>& __out, char __c)
|
||||
{
|
||||
typedef basic_ostream<char, _Traits> __ostream_type;
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb)
|
||||
{
|
||||
try
|
||||
{
|
||||
streamsize __w = __out.width();
|
||||
char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
|
||||
__pads[0] = __c;
|
||||
streamsize __len = 1;
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
|
||||
&__c, __w, __len, false);
|
||||
__len = __w;
|
||||
}
|
||||
__out.write(__pads, __len);
|
||||
__out.width(0);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
__out.setstate(ios_base::badbit);
|
||||
if ((__out.exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
return __out;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
|
||||
{
|
||||
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb && __s)
|
||||
{
|
||||
try
|
||||
{
|
||||
streamsize __w = __out.width();
|
||||
_CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
|
||||
streamsize __len = static_cast<streamsize>(_Traits::length(__s));
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
|
||||
__s, __w, __len, false);
|
||||
__s = __pads;
|
||||
__len = __w;
|
||||
}
|
||||
__out.write(__s, __len);
|
||||
__out.width(0);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
__out.setstate(ios_base::badbit);
|
||||
if ((__out.exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
else if (!__s)
|
||||
__out.setstate(ios_base::badbit);
|
||||
return __out;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
|
||||
{
|
||||
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 167. Improper use of traits_type::length()
|
||||
// Note that this is only in 'Review' status.
|
||||
typedef char_traits<char> __traits_type;
|
||||
#endif
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb && __s)
|
||||
{
|
||||
size_t __clen = __traits_type::length(__s);
|
||||
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__clen + 1)));
|
||||
for (size_t __i = 0; __i < __clen; ++__i)
|
||||
__ws[__i] = __out.widen(__s[__i]);
|
||||
_CharT* __str = __ws;
|
||||
|
||||
try
|
||||
{
|
||||
streamsize __len = static_cast<streamsize>(__clen);
|
||||
streamsize __w = __out.width();
|
||||
_CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
|
||||
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
|
||||
__ws, __w, __len, false);
|
||||
__str = __pads;
|
||||
__len = __w;
|
||||
}
|
||||
__out.write(__str, __len);
|
||||
__out.width(0);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
__out.setstate(ios_base::badbit);
|
||||
if ((__out.exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
else if (!__s)
|
||||
__out.setstate(ios_base::badbit);
|
||||
return __out;
|
||||
}
|
||||
|
||||
// Partial specializations.
|
||||
template<class _Traits>
|
||||
basic_ostream<char, _Traits>&
|
||||
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
|
||||
{
|
||||
typedef basic_ostream<char, _Traits> __ostream_type;
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb && __s)
|
||||
{
|
||||
try
|
||||
{
|
||||
streamsize __w = __out.width();
|
||||
char* __pads = static_cast<char*>(__builtin_alloca(__w));
|
||||
streamsize __len = static_cast<streamsize>(_Traits::length(__s));
|
||||
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
|
||||
__s, __w, __len, false);
|
||||
__s = __pads;
|
||||
__len = __w;
|
||||
}
|
||||
__out.write(__s, __len);
|
||||
__out.width(0);
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
// 27.6.1.2.1 Common requirements.
|
||||
// Turn this on without causing an ios::failure to be thrown.
|
||||
__out.setstate(ios_base::badbit);
|
||||
if ((__out.exceptions() & ios_base::badbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
else if (!__s)
|
||||
__out.setstate(ios_base::badbit);
|
||||
return __out;
|
||||
}
|
||||
|
||||
// 21.3.7.9 basic_string::operator<<
|
||||
template<typename _CharT, typename _Traits, typename _Alloc>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __out,
|
||||
const basic_string<_CharT, _Traits, _Alloc>& __str)
|
||||
{
|
||||
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
||||
typename __ostream_type::sentry __cerb(__out);
|
||||
if (__cerb)
|
||||
{
|
||||
const _CharT* __s = __str.data();
|
||||
streamsize __w = __out.width();
|
||||
_CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
|
||||
streamsize __len = static_cast<streamsize>(__str.size());
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 25. String operator<< uses width() value wrong
|
||||
#endif
|
||||
if (__w > __len)
|
||||
{
|
||||
__pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads, __s,
|
||||
__w, __len, false);
|
||||
__s = __pads;
|
||||
__len = __w;
|
||||
}
|
||||
streamsize __res = __out.rdbuf()->sputn(__s, __len);
|
||||
__out.width(0);
|
||||
if (__res != __len)
|
||||
__out.setstate(ios_base::failbit);
|
||||
}
|
||||
return __out;
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_ostream<char>;
|
||||
extern template ostream& endl(ostream&);
|
||||
extern template ostream& ends(ostream&);
|
||||
extern template ostream& flush(ostream&);
|
||||
extern template ostream& operator<<(ostream&, char);
|
||||
extern template ostream& operator<<(ostream&, unsigned char);
|
||||
extern template ostream& operator<<(ostream&, signed char);
|
||||
extern template ostream& operator<<(ostream&, const char*);
|
||||
extern template ostream& operator<<(ostream&, const unsigned char*);
|
||||
extern template ostream& operator<<(ostream&, const signed char*);
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_ostream<wchar_t>;
|
||||
extern template wostream& endl(wostream&);
|
||||
extern template wostream& ends(wostream&);
|
||||
extern template wostream& flush(wostream&);
|
||||
extern template wostream& operator<<(wostream&, wchar_t);
|
||||
extern template wostream& operator<<(wostream&, char);
|
||||
extern template wostream& operator<<(wostream&, const wchar_t*);
|
||||
extern template wostream& operator<<(wostream&, const char*);
|
||||
#endif
|
||||
} // namespace std
|
||||
525
TBE/MinGW/include/c++/3.2.3/bits/pthread_allocimpl.h
Normal file
525
TBE/MinGW/include/c++/3.2.3/bits/pthread_allocimpl.h
Normal file
@@ -0,0 +1,525 @@
|
||||
// POSIX thread-related memory allocation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file pthread_allocimpl.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_PTHREAD_ALLOCIMPL_H
|
||||
#define _CPP_BITS_PTHREAD_ALLOCIMPL_H 1
|
||||
|
||||
// Pthread-specific node allocator.
|
||||
// This is similar to the default allocator, except that free-list
|
||||
// information is kept separately for each thread, avoiding locking.
|
||||
// This should be reasonably fast even in the presence of threads.
|
||||
// The down side is that storage may not be well-utilized.
|
||||
// It is not an error to allocate memory in thread A and deallocate
|
||||
// it in thread B. But this effectively transfers ownership of the memory,
|
||||
// so that it can only be reallocated by thread B. Thus this can effectively
|
||||
// result in a storage leak if it's done on a regular basis.
|
||||
// It can also result in frequent sharing of
|
||||
// cache lines among processors, with potentially serious performance
|
||||
// consequences.
|
||||
|
||||
#include <bits/c++config.h>
|
||||
#include <cerrno>
|
||||
#include <bits/stl_alloc.h>
|
||||
#ifndef __RESTRICT
|
||||
# define __RESTRICT
|
||||
#endif
|
||||
|
||||
#include <new>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
#define __STL_DATA_ALIGNMENT 8
|
||||
|
||||
union _Pthread_alloc_obj {
|
||||
union _Pthread_alloc_obj * __free_list_link;
|
||||
char __client_data[__STL_DATA_ALIGNMENT]; /* The client sees this. */
|
||||
};
|
||||
|
||||
// Pthread allocators don't appear to the client to have meaningful
|
||||
// instances. We do in fact need to associate some state with each
|
||||
// thread. That state is represented by
|
||||
// _Pthread_alloc_per_thread_state<_Max_size>.
|
||||
|
||||
template<size_t _Max_size>
|
||||
struct _Pthread_alloc_per_thread_state {
|
||||
typedef _Pthread_alloc_obj __obj;
|
||||
enum { _S_NFREELISTS = _Max_size/__STL_DATA_ALIGNMENT };
|
||||
_Pthread_alloc_obj* volatile __free_list[_S_NFREELISTS];
|
||||
_Pthread_alloc_per_thread_state<_Max_size> * __next;
|
||||
// Free list link for list of available per thread structures.
|
||||
// When one of these becomes available for reuse due to thread
|
||||
// termination, any objects in its free list remain associated
|
||||
// with it. The whole structure may then be used by a newly
|
||||
// created thread.
|
||||
_Pthread_alloc_per_thread_state() : __next(0)
|
||||
{
|
||||
memset((void *)__free_list, 0, (size_t) _S_NFREELISTS * sizeof(__obj *));
|
||||
}
|
||||
// Returns an object of size __n, and possibly adds to size n free list.
|
||||
void *_M_refill(size_t __n);
|
||||
};
|
||||
|
||||
// Pthread-specific allocator.
|
||||
// The argument specifies the largest object size allocated from per-thread
|
||||
// free lists. Larger objects are allocated using malloc_alloc.
|
||||
// Max_size must be a power of 2.
|
||||
template <size_t _Max_size = 128>
|
||||
class _Pthread_alloc_template {
|
||||
|
||||
public: // but only for internal use:
|
||||
|
||||
typedef _Pthread_alloc_obj __obj;
|
||||
|
||||
// Allocates a chunk for nobjs of size size. nobjs may be reduced
|
||||
// if it is inconvenient to allocate the requested number.
|
||||
static char *_S_chunk_alloc(size_t __size, int &__nobjs);
|
||||
|
||||
enum {_S_ALIGN = __STL_DATA_ALIGNMENT};
|
||||
|
||||
static size_t _S_round_up(size_t __bytes) {
|
||||
return (((__bytes) + (int) _S_ALIGN-1) & ~((int) _S_ALIGN - 1));
|
||||
}
|
||||
static size_t _S_freelist_index(size_t __bytes) {
|
||||
return (((__bytes) + (int) _S_ALIGN-1)/(int)_S_ALIGN - 1);
|
||||
}
|
||||
|
||||
private:
|
||||
// Chunk allocation state. And other shared state.
|
||||
// Protected by _S_chunk_allocator_lock.
|
||||
static pthread_mutex_t _S_chunk_allocator_lock;
|
||||
static char *_S_start_free;
|
||||
static char *_S_end_free;
|
||||
static size_t _S_heap_size;
|
||||
static _Pthread_alloc_per_thread_state<_Max_size>* _S_free_per_thread_states;
|
||||
static pthread_key_t _S_key;
|
||||
static bool _S_key_initialized;
|
||||
// Pthread key under which per thread state is stored.
|
||||
// Allocator instances that are currently unclaimed by any thread.
|
||||
static void _S_destructor(void *instance);
|
||||
// Function to be called on thread exit to reclaim per thread
|
||||
// state.
|
||||
static _Pthread_alloc_per_thread_state<_Max_size> *_S_new_per_thread_state();
|
||||
// Return a recycled or new per thread state.
|
||||
static _Pthread_alloc_per_thread_state<_Max_size> *_S_get_per_thread_state();
|
||||
// ensure that the current thread has an associated
|
||||
// per thread state.
|
||||
class _M_lock;
|
||||
friend class _M_lock;
|
||||
class _M_lock {
|
||||
public:
|
||||
_M_lock () { pthread_mutex_lock(&_S_chunk_allocator_lock); }
|
||||
~_M_lock () { pthread_mutex_unlock(&_S_chunk_allocator_lock); }
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
/* n must be > 0 */
|
||||
static void * allocate(size_t __n)
|
||||
{
|
||||
__obj * volatile * __my_free_list;
|
||||
__obj * __RESTRICT __result;
|
||||
_Pthread_alloc_per_thread_state<_Max_size>* __a;
|
||||
|
||||
if (__n > _Max_size) {
|
||||
return(malloc_alloc::allocate(__n));
|
||||
}
|
||||
if (!_S_key_initialized ||
|
||||
!(__a = (_Pthread_alloc_per_thread_state<_Max_size>*)
|
||||
pthread_getspecific(_S_key))) {
|
||||
__a = _S_get_per_thread_state();
|
||||
}
|
||||
__my_free_list = __a -> __free_list + _S_freelist_index(__n);
|
||||
__result = *__my_free_list;
|
||||
if (__result == 0) {
|
||||
void *__r = __a -> _M_refill(_S_round_up(__n));
|
||||
return __r;
|
||||
}
|
||||
*__my_free_list = __result -> __free_list_link;
|
||||
return (__result);
|
||||
};
|
||||
|
||||
/* p may not be 0 */
|
||||
static void deallocate(void *__p, size_t __n)
|
||||
{
|
||||
__obj *__q = (__obj *)__p;
|
||||
__obj * volatile * __my_free_list;
|
||||
_Pthread_alloc_per_thread_state<_Max_size>* __a;
|
||||
|
||||
if (__n > _Max_size) {
|
||||
malloc_alloc::deallocate(__p, __n);
|
||||
return;
|
||||
}
|
||||
if (!_S_key_initialized ||
|
||||
!(__a = (_Pthread_alloc_per_thread_state<_Max_size> *)
|
||||
pthread_getspecific(_S_key))) {
|
||||
__a = _S_get_per_thread_state();
|
||||
}
|
||||
__my_free_list = __a->__free_list + _S_freelist_index(__n);
|
||||
__q -> __free_list_link = *__my_free_list;
|
||||
*__my_free_list = __q;
|
||||
}
|
||||
|
||||
static void * reallocate(void *__p, size_t __old_sz, size_t __new_sz);
|
||||
|
||||
} ;
|
||||
|
||||
typedef _Pthread_alloc_template<> pthread_alloc;
|
||||
|
||||
|
||||
template <size_t _Max_size>
|
||||
void _Pthread_alloc_template<_Max_size>::_S_destructor(void * __instance)
|
||||
{
|
||||
_M_lock __lock_instance; // Need to acquire lock here.
|
||||
_Pthread_alloc_per_thread_state<_Max_size>* __s =
|
||||
(_Pthread_alloc_per_thread_state<_Max_size> *)__instance;
|
||||
__s -> __next = _S_free_per_thread_states;
|
||||
_S_free_per_thread_states = __s;
|
||||
}
|
||||
|
||||
template <size_t _Max_size>
|
||||
_Pthread_alloc_per_thread_state<_Max_size> *
|
||||
_Pthread_alloc_template<_Max_size>::_S_new_per_thread_state()
|
||||
{
|
||||
/* lock already held here. */
|
||||
if (0 != _S_free_per_thread_states) {
|
||||
_Pthread_alloc_per_thread_state<_Max_size> *__result =
|
||||
_S_free_per_thread_states;
|
||||
_S_free_per_thread_states = _S_free_per_thread_states -> __next;
|
||||
return __result;
|
||||
} else {
|
||||
return new _Pthread_alloc_per_thread_state<_Max_size>;
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t _Max_size>
|
||||
_Pthread_alloc_per_thread_state<_Max_size> *
|
||||
_Pthread_alloc_template<_Max_size>::_S_get_per_thread_state()
|
||||
{
|
||||
/*REFERENCED*/
|
||||
_M_lock __lock_instance; // Need to acquire lock here.
|
||||
int __ret_code;
|
||||
_Pthread_alloc_per_thread_state<_Max_size> * __result;
|
||||
if (!_S_key_initialized) {
|
||||
if (pthread_key_create(&_S_key, _S_destructor)) {
|
||||
std::__throw_bad_alloc(); // defined in funcexcept.h
|
||||
}
|
||||
_S_key_initialized = true;
|
||||
}
|
||||
__result = _S_new_per_thread_state();
|
||||
__ret_code = pthread_setspecific(_S_key, __result);
|
||||
if (__ret_code) {
|
||||
if (__ret_code == ENOMEM) {
|
||||
std::__throw_bad_alloc();
|
||||
} else {
|
||||
// EINVAL
|
||||
abort();
|
||||
}
|
||||
}
|
||||
return __result;
|
||||
}
|
||||
|
||||
/* We allocate memory in large chunks in order to avoid fragmenting */
|
||||
/* the malloc heap too much. */
|
||||
/* We assume that size is properly aligned. */
|
||||
template <size_t _Max_size>
|
||||
char *_Pthread_alloc_template<_Max_size>
|
||||
::_S_chunk_alloc(size_t __size, int &__nobjs)
|
||||
{
|
||||
{
|
||||
char * __result;
|
||||
size_t __total_bytes;
|
||||
size_t __bytes_left;
|
||||
/*REFERENCED*/
|
||||
_M_lock __lock_instance; // Acquire lock for this routine
|
||||
|
||||
__total_bytes = __size * __nobjs;
|
||||
__bytes_left = _S_end_free - _S_start_free;
|
||||
if (__bytes_left >= __total_bytes) {
|
||||
__result = _S_start_free;
|
||||
_S_start_free += __total_bytes;
|
||||
return(__result);
|
||||
} else if (__bytes_left >= __size) {
|
||||
__nobjs = __bytes_left/__size;
|
||||
__total_bytes = __size * __nobjs;
|
||||
__result = _S_start_free;
|
||||
_S_start_free += __total_bytes;
|
||||
return(__result);
|
||||
} else {
|
||||
size_t __bytes_to_get =
|
||||
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
|
||||
// Try to make use of the left-over piece.
|
||||
if (__bytes_left > 0) {
|
||||
_Pthread_alloc_per_thread_state<_Max_size>* __a =
|
||||
(_Pthread_alloc_per_thread_state<_Max_size>*)
|
||||
pthread_getspecific(_S_key);
|
||||
__obj * volatile * __my_free_list =
|
||||
__a->__free_list + _S_freelist_index(__bytes_left);
|
||||
|
||||
((__obj *)_S_start_free) -> __free_list_link = *__my_free_list;
|
||||
*__my_free_list = (__obj *)_S_start_free;
|
||||
}
|
||||
# ifdef _SGI_SOURCE
|
||||
// Try to get memory that's aligned on something like a
|
||||
// cache line boundary, so as to avoid parceling out
|
||||
// parts of the same line to different threads and thus
|
||||
// possibly different processors.
|
||||
{
|
||||
const int __cache_line_size = 128; // probable upper bound
|
||||
__bytes_to_get &= ~(__cache_line_size-1);
|
||||
_S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get);
|
||||
if (0 == _S_start_free) {
|
||||
_S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get);
|
||||
}
|
||||
}
|
||||
# else /* !SGI_SOURCE */
|
||||
_S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get);
|
||||
# endif
|
||||
_S_heap_size += __bytes_to_get;
|
||||
_S_end_free = _S_start_free + __bytes_to_get;
|
||||
}
|
||||
}
|
||||
// lock is released here
|
||||
return(_S_chunk_alloc(__size, __nobjs));
|
||||
}
|
||||
|
||||
|
||||
/* Returns an object of size n, and optionally adds to size n free list.*/
|
||||
/* We assume that n is properly aligned. */
|
||||
/* We hold the allocation lock. */
|
||||
template <size_t _Max_size>
|
||||
void *_Pthread_alloc_per_thread_state<_Max_size>
|
||||
::_M_refill(size_t __n)
|
||||
{
|
||||
int __nobjs = 128;
|
||||
char * __chunk =
|
||||
_Pthread_alloc_template<_Max_size>::_S_chunk_alloc(__n, __nobjs);
|
||||
__obj * volatile * __my_free_list;
|
||||
__obj * __result;
|
||||
__obj * __current_obj, * __next_obj;
|
||||
int __i;
|
||||
|
||||
if (1 == __nobjs) {
|
||||
return(__chunk);
|
||||
}
|
||||
__my_free_list = __free_list
|
||||
+ _Pthread_alloc_template<_Max_size>::_S_freelist_index(__n);
|
||||
|
||||
/* Build free list in chunk */
|
||||
__result = (__obj *)__chunk;
|
||||
*__my_free_list = __next_obj = (__obj *)(__chunk + __n);
|
||||
for (__i = 1; ; __i++) {
|
||||
__current_obj = __next_obj;
|
||||
__next_obj = (__obj *)((char *)__next_obj + __n);
|
||||
if (__nobjs - 1 == __i) {
|
||||
__current_obj -> __free_list_link = 0;
|
||||
break;
|
||||
} else {
|
||||
__current_obj -> __free_list_link = __next_obj;
|
||||
}
|
||||
}
|
||||
return(__result);
|
||||
}
|
||||
|
||||
template <size_t _Max_size>
|
||||
void *_Pthread_alloc_template<_Max_size>
|
||||
::reallocate(void *__p, size_t __old_sz, size_t __new_sz)
|
||||
{
|
||||
void * __result;
|
||||
size_t __copy_sz;
|
||||
|
||||
if (__old_sz > _Max_size
|
||||
&& __new_sz > _Max_size) {
|
||||
return(realloc(__p, __new_sz));
|
||||
}
|
||||
if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);
|
||||
__result = allocate(__new_sz);
|
||||
__copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
|
||||
memcpy(__result, __p, __copy_sz);
|
||||
deallocate(__p, __old_sz);
|
||||
return(__result);
|
||||
}
|
||||
|
||||
template <size_t _Max_size>
|
||||
_Pthread_alloc_per_thread_state<_Max_size> *
|
||||
_Pthread_alloc_template<_Max_size>::_S_free_per_thread_states = 0;
|
||||
|
||||
template <size_t _Max_size>
|
||||
pthread_key_t _Pthread_alloc_template<_Max_size>::_S_key;
|
||||
|
||||
template <size_t _Max_size>
|
||||
bool _Pthread_alloc_template<_Max_size>::_S_key_initialized = false;
|
||||
|
||||
template <size_t _Max_size>
|
||||
pthread_mutex_t _Pthread_alloc_template<_Max_size>::_S_chunk_allocator_lock
|
||||
= PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
template <size_t _Max_size>
|
||||
char *_Pthread_alloc_template<_Max_size>
|
||||
::_S_start_free = 0;
|
||||
|
||||
template <size_t _Max_size>
|
||||
char *_Pthread_alloc_template<_Max_size>
|
||||
::_S_end_free = 0;
|
||||
|
||||
template <size_t _Max_size>
|
||||
size_t _Pthread_alloc_template<_Max_size>
|
||||
::_S_heap_size = 0;
|
||||
|
||||
|
||||
template <class _Tp>
|
||||
class pthread_allocator {
|
||||
typedef pthread_alloc _S_Alloc; // The underlying allocator.
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef const _Tp* const_pointer;
|
||||
typedef _Tp& reference;
|
||||
typedef const _Tp& const_reference;
|
||||
typedef _Tp value_type;
|
||||
|
||||
template <class _NewType> struct rebind {
|
||||
typedef pthread_allocator<_NewType> other;
|
||||
};
|
||||
|
||||
pthread_allocator() throw() {}
|
||||
pthread_allocator(const pthread_allocator& a) throw() {}
|
||||
template <class _OtherType>
|
||||
pthread_allocator(const pthread_allocator<_OtherType>&)
|
||||
throw() {}
|
||||
~pthread_allocator() throw() {}
|
||||
|
||||
pointer address(reference __x) const { return &__x; }
|
||||
const_pointer address(const_reference __x) const { return &__x; }
|
||||
|
||||
// __n is permitted to be 0. The C++ standard says nothing about what
|
||||
// the return value is when __n == 0.
|
||||
_Tp* allocate(size_type __n, const void* = 0) {
|
||||
return __n != 0 ? static_cast<_Tp*>(_S_Alloc::allocate(__n * sizeof(_Tp)))
|
||||
: 0;
|
||||
}
|
||||
|
||||
// p is not permitted to be a null pointer.
|
||||
void deallocate(pointer __p, size_type __n)
|
||||
{ _S_Alloc::deallocate(__p, __n * sizeof(_Tp)); }
|
||||
|
||||
size_type max_size() const throw()
|
||||
{ return size_t(-1) / sizeof(_Tp); }
|
||||
|
||||
void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
|
||||
void destroy(pointer _p) { _p->~_Tp(); }
|
||||
};
|
||||
|
||||
template<>
|
||||
class pthread_allocator<void> {
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef void* pointer;
|
||||
typedef const void* const_pointer;
|
||||
typedef void value_type;
|
||||
|
||||
template <class _NewType> struct rebind {
|
||||
typedef pthread_allocator<_NewType> other;
|
||||
};
|
||||
};
|
||||
|
||||
template <size_t _Max_size>
|
||||
inline bool operator==(const _Pthread_alloc_template<_Max_size>&,
|
||||
const _Pthread_alloc_template<_Max_size>&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline bool operator==(const pthread_allocator<_T1>&,
|
||||
const pthread_allocator<_T2>& a2)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline bool operator!=(const pthread_allocator<_T1>&,
|
||||
const pthread_allocator<_T2>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template <class _Tp, size_t _Max_size>
|
||||
struct _Alloc_traits<_Tp, _Pthread_alloc_template<_Max_size> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max_size> > _Alloc_type;
|
||||
typedef __allocator<_Tp, _Pthread_alloc_template<_Max_size> >
|
||||
allocator_type;
|
||||
};
|
||||
|
||||
template <class _Tp, class _Atype, size_t _Max>
|
||||
struct _Alloc_traits<_Tp, __allocator<_Atype, _Pthread_alloc_template<_Max> > >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max> > _Alloc_type;
|
||||
typedef __allocator<_Tp, _Pthread_alloc_template<_Max> > allocator_type;
|
||||
};
|
||||
|
||||
template <class _Tp, class _Atype>
|
||||
struct _Alloc_traits<_Tp, pthread_allocator<_Atype> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef simple_alloc<_Tp, _Pthread_alloc_template<> > _Alloc_type;
|
||||
typedef pthread_allocator<_Tp> allocator_type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_PTHREAD_ALLOCIMPL_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
85
TBE/MinGW/include/c++/3.2.3/bits/slice.h
Normal file
85
TBE/MinGW/include/c++/3.2.3/bits/slice.h
Normal file
@@ -0,0 +1,85 @@
|
||||
// The template and inlines for the -*- C++ -*- slice class.
|
||||
|
||||
// Copyright (C) 1997-1999, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file slice.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_SLICE_H
|
||||
#define _CPP_BITS_SLICE_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
class slice
|
||||
{
|
||||
public:
|
||||
slice ();
|
||||
slice (size_t, size_t, size_t);
|
||||
|
||||
size_t start () const;
|
||||
size_t size () const;
|
||||
size_t stride () const;
|
||||
|
||||
private:
|
||||
size_t _M_off; // offset
|
||||
size_t _M_sz; // size
|
||||
size_t _M_st; // stride unit
|
||||
};
|
||||
|
||||
inline slice::slice () {}
|
||||
|
||||
inline slice::slice (size_t __o, size_t __d, size_t __s)
|
||||
: _M_off (__o), _M_sz (__d), _M_st (__s) {}
|
||||
|
||||
inline size_t
|
||||
slice::start () const
|
||||
{ return _M_off; }
|
||||
|
||||
inline size_t
|
||||
slice::size () const
|
||||
{ return _M_sz; }
|
||||
|
||||
inline size_t
|
||||
slice::stride () const
|
||||
{ return _M_st; }
|
||||
|
||||
} // std::
|
||||
|
||||
|
||||
#endif /* _CPP_BITS_SLICE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
181
TBE/MinGW/include/c++/3.2.3/bits/slice_array.h
Normal file
181
TBE/MinGW/include/c++/3.2.3/bits/slice_array.h
Normal file
@@ -0,0 +1,181 @@
|
||||
// The template and inlines for the -*- C++ -*- slice_array class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file slice_array.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_SLICE_ARRAY_H
|
||||
#define _CPP_BITS_SLICE_ARRAY_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
template<typename _Tp>
|
||||
class slice_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
// This constructor is implemented since we need to return a value.
|
||||
slice_array (const slice_array&);
|
||||
|
||||
// This operator must be public. See DR-253.
|
||||
slice_array& operator= (const slice_array&);
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<= (const valarray<_Tp>&) const;
|
||||
void operator>>= (const valarray<_Tp>&) const;
|
||||
void operator= (const _Tp &);
|
||||
// ~slice_array ();
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_Tp>&) const;
|
||||
|
||||
private:
|
||||
friend class valarray<_Tp>;
|
||||
slice_array(_Array<_Tp>, const slice&);
|
||||
|
||||
const size_t _M_sz;
|
||||
const size_t _M_stride;
|
||||
const _Array<_Tp> _M_array;
|
||||
|
||||
// not implemented
|
||||
slice_array ();
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>::slice_array (_Array<_Tp> __a, const slice& __s)
|
||||
: _M_sz (__s.size ()), _M_stride (__s.stride ()),
|
||||
_M_array (__a.begin () + __s.start ()) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
|
||||
: _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
|
||||
|
||||
// template<typename _Tp>
|
||||
// inline slice_array<_Tp>::~slice_array () {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>&
|
||||
slice_array<_Tp>::operator=(const slice_array<_Tp>& __a)
|
||||
{
|
||||
__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
|
||||
_M_array, _M_stride);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
slice_array<_Tp>::operator= (const _Tp& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
slice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{ __valarray_copy (_Array<_Tp> (__v), _M_array, _M_sz, _M_stride); }
|
||||
|
||||
template<typename _Tp>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
slice_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
slice_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_Tp> (__v));\
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class _Dom> \
|
||||
inline void \
|
||||
slice_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_stride, __e, _M_sz); \
|
||||
}
|
||||
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // std::
|
||||
|
||||
#endif /* _CPP_BITS_SLICE_ARRAY_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
241
TBE/MinGW/include/c++/3.2.3/bits/sstream.tcc
Normal file
241
TBE/MinGW/include/c++/3.2.3/bits/sstream.tcc
Normal file
@@ -0,0 +1,241 @@
|
||||
// String based streams -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27.7 String-based streams
|
||||
//
|
||||
|
||||
#ifndef _CPP_BITS_SSTREAM_TCC
|
||||
#define _CPP_BITS_SSTREAM_TCC 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <sstream>
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <class _CharT, class _Traits, class _Alloc>
|
||||
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
|
||||
basic_stringbuf<_CharT, _Traits, _Alloc>::
|
||||
pbackfail(int_type __c)
|
||||
{
|
||||
int_type __ret = traits_type::eof();
|
||||
bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
|
||||
bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
|
||||
|
||||
// Try to put back __c into input sequence in one of three ways.
|
||||
// Order these tests done in is unspecified by the standard.
|
||||
if (__testpos)
|
||||
{
|
||||
if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])
|
||||
&& !__testeof)
|
||||
{
|
||||
--_M_in_cur;
|
||||
__ret = __c;
|
||||
}
|
||||
else if (!__testeof)
|
||||
{
|
||||
--_M_in_cur;
|
||||
*_M_in_cur = traits_type::to_char_type(__c);
|
||||
__ret = __c;
|
||||
}
|
||||
else if (__testeof)
|
||||
{
|
||||
--_M_in_cur;
|
||||
__ret = traits_type::not_eof(__c);
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Alloc>
|
||||
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
|
||||
basic_stringbuf<_CharT, _Traits, _Alloc>::
|
||||
overflow(int_type __c)
|
||||
{
|
||||
int_type __ret = traits_type::eof();
|
||||
bool __testeof = traits_type::eq_int_type(__c, __ret);
|
||||
bool __testwrite = _M_out_cur < _M_buf + _M_buf_size;
|
||||
bool __testout = _M_mode & ios_base::out;
|
||||
|
||||
// Try to append __c into output sequence in one of two ways.
|
||||
// Order these tests done in is unspecified by the standard.
|
||||
if (__testout)
|
||||
{
|
||||
if (!__testeof)
|
||||
{
|
||||
__size_type __len = max(_M_buf_size, _M_buf_size_opt);
|
||||
__len *= 2;
|
||||
|
||||
if (__testwrite)
|
||||
__ret = this->sputc(traits_type::to_char_type(__c));
|
||||
else if (__len <= _M_string.max_size())
|
||||
{
|
||||
// Force-allocate, re-sync.
|
||||
_M_string = this->str();
|
||||
_M_string.reserve(__len);
|
||||
_M_buf_size = __len;
|
||||
_M_really_sync(_M_in_cur - _M_in_beg,
|
||||
_M_out_cur - _M_out_beg);
|
||||
*_M_out_cur = traits_type::to_char_type(__c);
|
||||
_M_out_cur_move(1);
|
||||
__ret = __c;
|
||||
}
|
||||
}
|
||||
else
|
||||
__ret = traits_type::not_eof(__c);
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Alloc>
|
||||
typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
|
||||
basic_stringbuf<_CharT, _Traits, _Alloc>::
|
||||
seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
|
||||
{
|
||||
pos_type __ret = pos_type(off_type(-1));
|
||||
bool __testin = (ios_base::in & _M_mode & __mode) != 0;
|
||||
bool __testout = (ios_base::out & _M_mode & __mode) != 0;
|
||||
bool __testboth = __testin && __testout && __way != ios_base::cur;
|
||||
__testin &= !(__mode & ios_base::out);
|
||||
__testout &= !(__mode & ios_base::in);
|
||||
|
||||
if (_M_buf_size && (__testin || __testout || __testboth))
|
||||
{
|
||||
char_type* __beg = _M_buf;
|
||||
char_type* __curi = NULL;
|
||||
char_type* __curo = NULL;
|
||||
char_type* __endi = NULL;
|
||||
char_type* __endo = NULL;
|
||||
|
||||
if (__testin || __testboth)
|
||||
{
|
||||
__curi = this->gptr();
|
||||
__endi = this->egptr();
|
||||
}
|
||||
if (__testout || __testboth)
|
||||
{
|
||||
__curo = this->pptr();
|
||||
__endo = this->epptr();
|
||||
}
|
||||
|
||||
off_type __newoffi = 0;
|
||||
off_type __newoffo = 0;
|
||||
if (__way == ios_base::cur)
|
||||
{
|
||||
__newoffi = __curi - __beg;
|
||||
__newoffo = __curo - __beg;
|
||||
}
|
||||
else if (__way == ios_base::end)
|
||||
{
|
||||
__newoffi = __endi - __beg;
|
||||
__newoffo = __endo - __beg;
|
||||
}
|
||||
|
||||
if ((__testin || __testboth)
|
||||
&& __newoffi + __off >= 0 && __endi - __beg >= __newoffi + __off)
|
||||
{
|
||||
_M_in_cur = __beg + __newoffi + __off;
|
||||
__ret = pos_type(__newoffi);
|
||||
}
|
||||
if ((__testout || __testboth)
|
||||
&& __newoffo + __off >= 0 && __endo - __beg >= __newoffo + __off)
|
||||
{
|
||||
_M_out_cur_move(__newoffo + __off - (_M_out_cur - __beg));
|
||||
__ret = pos_type(__newoffo);
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Alloc>
|
||||
typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
|
||||
basic_stringbuf<_CharT, _Traits, _Alloc>::
|
||||
seekpos(pos_type __sp, ios_base::openmode __mode)
|
||||
{
|
||||
pos_type __ret = pos_type(off_type(-1));
|
||||
|
||||
if (_M_buf_size)
|
||||
{
|
||||
off_type __pos = __sp; // Use streamoff operator to do conversion.
|
||||
char_type* __beg = NULL;
|
||||
char_type* __end = NULL;
|
||||
bool __testin = (ios_base::in & _M_mode & __mode) != 0;
|
||||
bool __testout = (ios_base::out & _M_mode & __mode) != 0;
|
||||
bool __testboth = __testin && __testout;
|
||||
__testin &= !(__mode & ios_base::out);
|
||||
__testout &= !(__mode & ios_base::in);
|
||||
|
||||
// NB: Ordered.
|
||||
bool __testposi = false;
|
||||
bool __testposo = false;
|
||||
if (__testin || __testboth)
|
||||
{
|
||||
__beg = this->eback();
|
||||
__end = this->egptr();
|
||||
if (0 <= __pos && __pos <= __end - __beg)
|
||||
__testposi = true;
|
||||
}
|
||||
if (__testout || __testboth)
|
||||
{
|
||||
__beg = this->pbase();
|
||||
__end = _M_buf + _M_buf_size;
|
||||
if (0 <= __pos && __pos <= __end - __beg)
|
||||
__testposo = true;
|
||||
}
|
||||
if (__testposi || __testposo)
|
||||
{
|
||||
if (__testposi)
|
||||
_M_in_cur = _M_in_beg + __pos;
|
||||
if (__testposo)
|
||||
_M_out_cur_move((__pos) - (_M_out_cur - __beg));
|
||||
__ret = pos_type(off_type(__pos));
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_stringbuf<char>;
|
||||
extern template class basic_istringstream<char>;
|
||||
extern template class basic_ostringstream<char>;
|
||||
extern template class basic_stringstream<char>;
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_stringbuf<wchar_t>;
|
||||
extern template class basic_istringstream<wchar_t>;
|
||||
extern template class basic_ostringstream<wchar_t>;
|
||||
extern template class basic_stringstream<wchar_t>;
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
4351
TBE/MinGW/include/c++/3.2.3/bits/stl_algo.h
Normal file
4351
TBE/MinGW/include/c++/3.2.3/bits/stl_algo.h
Normal file
File diff suppressed because it is too large
Load Diff
820
TBE/MinGW/include/c++/3.2.3/bits/stl_algobase.h
Normal file
820
TBE/MinGW/include/c++/3.2.3/bits/stl_algobase.h
Normal file
@@ -0,0 +1,820 @@
|
||||
// Bits and pieces used in algorithms -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_algobase.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_ALGOBASE_H
|
||||
#define __GLIBCPP_INTERNAL_ALGOBASE_H
|
||||
|
||||
#include <bits/c++config.h>
|
||||
#include <cstring>
|
||||
#include <climits>
|
||||
#include <cstdlib>
|
||||
#include <cstddef>
|
||||
#include <new>
|
||||
#include <iosfwd>
|
||||
#include <bits/stl_pair.h>
|
||||
#include <bits/type_traits.h>
|
||||
#include <bits/stl_iterator_base_types.h>
|
||||
#include <bits/stl_iterator_base_funcs.h>
|
||||
#include <bits/stl_iterator.h>
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// swap and iter_swap
|
||||
|
||||
/**
|
||||
* @brief Swaps the contents of two iterators.
|
||||
* @param a An iterator.
|
||||
* @param b Another iterator.
|
||||
* @return Nothing.
|
||||
*
|
||||
* This function swaps the values pointed to by two iterators, not the
|
||||
* iterators themselves.
|
||||
*/
|
||||
template<typename _ForwardIter1, typename _ForwardIter2>
|
||||
inline void
|
||||
iter_swap(_ForwardIter1 __a, _ForwardIter2 __b)
|
||||
{
|
||||
typedef typename iterator_traits<_ForwardIter1>::value_type _ValueType1;
|
||||
typedef typename iterator_traits<_ForwardIter2>::value_type _ValueType2;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>)
|
||||
__glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>)
|
||||
__glibcpp_function_requires(_ConvertibleConcept<_ValueType1, _ValueType2>)
|
||||
__glibcpp_function_requires(_ConvertibleConcept<_ValueType2, _ValueType1>)
|
||||
|
||||
_ValueType1 __tmp = *__a;
|
||||
*__a = *__b;
|
||||
*__b = __tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Swaps two values.
|
||||
* @param a A thing of arbitrary type.
|
||||
* @param b Another thing of arbitrary type.
|
||||
* @return Nothing.
|
||||
*
|
||||
* This is the simple classic generic implementation. It will work on
|
||||
* any type which has a copy constructor and an assignment operator.
|
||||
*/
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
swap(_Tp& __a, _Tp& __b)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_SGIAssignableConcept<_Tp>)
|
||||
|
||||
_Tp __tmp = __a;
|
||||
__a = __b;
|
||||
__b = __tmp;
|
||||
}
|
||||
|
||||
//--------------------------------------------------
|
||||
// min and max
|
||||
|
||||
#undef min
|
||||
#undef max
|
||||
|
||||
/**
|
||||
* @brief This does what you think it does.
|
||||
* @param a A thing of arbitrary type.
|
||||
* @param b Another thing of arbitrary type.
|
||||
* @return The lesser of the parameters.
|
||||
*
|
||||
* This is the simple classic generic implementation. It will work on
|
||||
* temporary expressions, since they are only evaluated once, unlike a
|
||||
* preprocessor macro.
|
||||
*/
|
||||
template<typename _Tp>
|
||||
inline const _Tp&
|
||||
min(const _Tp& __a, const _Tp& __b)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
|
||||
//return __b < __a ? __b : __a;
|
||||
if (__b < __a) return __b; return __a;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This does what you think it does.
|
||||
* @param a A thing of arbitrary type.
|
||||
* @param b Another thing of arbitrary type.
|
||||
* @return The greater of the parameters.
|
||||
*
|
||||
* This is the simple classic generic implementation. It will work on
|
||||
* temporary expressions, since they are only evaluated once, unlike a
|
||||
* preprocessor macro.
|
||||
*/
|
||||
template<typename _Tp>
|
||||
inline const _Tp&
|
||||
max(const _Tp& __a, const _Tp& __b)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
|
||||
//return __a < __b ? __b : __a;
|
||||
if (__a < __b) return __b; return __a;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This does what you think it does.
|
||||
* @param a A thing of arbitrary type.
|
||||
* @param b Another thing of arbitrary type.
|
||||
* @param comp A @link s20_3_3_comparisons comparison functor@endlink.
|
||||
* @return The lesser of the parameters.
|
||||
*
|
||||
* This will work on temporary expressions, since they are only evaluated
|
||||
* once, unlike a preprocessor macro.
|
||||
*/
|
||||
template<typename _Tp, typename _Compare>
|
||||
inline const _Tp&
|
||||
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
|
||||
{
|
||||
//return __comp(__b, __a) ? __b : __a;
|
||||
if (__comp(__b, __a)) return __b; return __a;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This does what you think it does.
|
||||
* @param a A thing of arbitrary type.
|
||||
* @param b Another thing of arbitrary type.
|
||||
* @param comp A @link s20_3_3_comparisons comparison functor@endlink.
|
||||
* @return The greater of the parameters.
|
||||
*
|
||||
* This will work on temporary expressions, since they are only evaluated
|
||||
* once, unlike a preprocessor macro.
|
||||
*/
|
||||
template<typename _Tp, typename _Compare>
|
||||
inline const _Tp&
|
||||
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
|
||||
{
|
||||
//return __comp(__a, __b) ? __b : __a;
|
||||
if (__comp(__a, __b)) return __b; return __a;
|
||||
}
|
||||
|
||||
//--------------------------------------------------
|
||||
// copy
|
||||
|
||||
// All of these auxiliary functions serve two purposes. (1) Replace
|
||||
// calls to copy with memmove whenever possible. (Memmove, not memcpy,
|
||||
// because the input and output ranges are permitted to overlap.)
|
||||
// (2) If we're using random access iterators, then write the loop as
|
||||
// a for loop with an explicit count.
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result,
|
||||
input_iterator_tag)
|
||||
{
|
||||
for ( ; __first != __last; ++__result, ++__first)
|
||||
*__result = *__first;
|
||||
return __result;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy(_RandomAccessIter __first, _RandomAccessIter __last,
|
||||
_OutputIter __result,
|
||||
random_access_iterator_tag)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIter>::difference_type
|
||||
_Distance;
|
||||
for (_Distance __n = __last - __first; __n > 0; --__n) {
|
||||
*__result = *__first;
|
||||
++__first;
|
||||
++__result;
|
||||
}
|
||||
return __result;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result)
|
||||
{
|
||||
memmove(__result, __first, sizeof(_Tp) * (__last - __first));
|
||||
return __result + (__last - __first);
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_aux2(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __false_type)
|
||||
{ return __copy(__first, __last, __result, __iterator_category(__first)); }
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_aux2(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __true_type)
|
||||
{ return __copy(__first, __last, __result, __iterator_category(__first)); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
__copy_aux2(_Tp* __first, _Tp* __last,
|
||||
_Tp* __result, __true_type)
|
||||
{ return __copy_trivial(__first, __last, __result); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
__copy_aux2(const _Tp* __first, const _Tp* __last,
|
||||
_Tp* __result, __true_type)
|
||||
{ return __copy_trivial(__first, __last, __result); }
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_ni2(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __true_type)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIter>::value_type
|
||||
_ValueType;
|
||||
typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
|
||||
_Trivial;
|
||||
return _OutputIter(__copy_aux2(__first, __last,
|
||||
__result.base(),
|
||||
_Trivial()));
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_ni2(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __false_type)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIter>::value_type
|
||||
_ValueType;
|
||||
typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
|
||||
_Trivial;
|
||||
return __copy_aux2(__first, __last,
|
||||
__result,
|
||||
_Trivial());
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_ni1(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __true_type)
|
||||
{
|
||||
typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
|
||||
return __copy_ni2(__first.base(), __last.base(), __result, __Normal());
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
__copy_ni1(_InputIter __first, _InputIter __last,
|
||||
_OutputIter __result, __false_type)
|
||||
{
|
||||
typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
|
||||
return __copy_ni2(__first, __last, __result, __Normal());
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copies the range [first,last) into result.
|
||||
* @param first An input iterator.
|
||||
* @param last An input iterator.
|
||||
* @param result An output iterator.
|
||||
* @return result + (first - last)
|
||||
*
|
||||
* This inline function will boil down to a call to @c memmove whenever
|
||||
* possible. Failing that, if random access iterators are passed, then the
|
||||
* loop count will be known (and therefore a candidate for compiler
|
||||
* optimizations such as unrolling). If the input range and the output
|
||||
* range overlap, then the copy_backward function should be used instead.
|
||||
*/
|
||||
template<typename _InputIter, typename _OutputIter>
|
||||
inline _OutputIter
|
||||
copy(_InputIter __first, _InputIter __last, _OutputIter __result)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
|
||||
typename iterator_traits<_InputIter>::value_type>)
|
||||
|
||||
typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
|
||||
return __copy_ni1(__first, __last, __result, __Normal());
|
||||
}
|
||||
|
||||
//--------------------------------------------------
|
||||
// copy_backward
|
||||
|
||||
template<typename _BidirectionalIter1, typename _BidirectionalIter2>
|
||||
inline _BidirectionalIter2
|
||||
__copy_backward(_BidirectionalIter1 __first, _BidirectionalIter1 __last,
|
||||
_BidirectionalIter2 __result,
|
||||
bidirectional_iterator_tag)
|
||||
{
|
||||
while (__first != __last)
|
||||
*--__result = *--__last;
|
||||
return __result;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIter, typename _BidirectionalIter>
|
||||
inline _BidirectionalIter
|
||||
__copy_backward(_RandomAccessIter __first, _RandomAccessIter __last,
|
||||
_BidirectionalIter __result,
|
||||
random_access_iterator_tag)
|
||||
{
|
||||
typename iterator_traits<_RandomAccessIter>::difference_type __n;
|
||||
for (__n = __last - __first; __n > 0; --__n)
|
||||
*--__result = *--__last;
|
||||
return __result;
|
||||
}
|
||||
|
||||
|
||||
// This dispatch class is a workaround for compilers that do not
|
||||
// have partial ordering of function templates. All we're doing is
|
||||
// creating a specialization so that we can turn a call to copy_backward
|
||||
// into a memmove whenever possible.
|
||||
|
||||
template<typename _BidirectionalIter1, typename _BidirectionalIter2,
|
||||
typename _BoolType>
|
||||
struct __copy_backward_dispatch
|
||||
{
|
||||
static _BidirectionalIter2
|
||||
copy(_BidirectionalIter1 __first, _BidirectionalIter1 __last,
|
||||
_BidirectionalIter2 __result)
|
||||
{
|
||||
return __copy_backward(__first, __last,
|
||||
__result,
|
||||
__iterator_category(__first));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
|
||||
{
|
||||
static _Tp*
|
||||
copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
|
||||
{
|
||||
const ptrdiff_t _Num = __last - __first;
|
||||
memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
|
||||
return __result - _Num;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
|
||||
{
|
||||
static _Tp*
|
||||
copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
|
||||
{
|
||||
return __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
|
||||
::copy(__first, __last, __result);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
__copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result)
|
||||
{
|
||||
typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
|
||||
::has_trivial_assignment_operator _Trivial;
|
||||
return __copy_backward_dispatch<_BI1, _BI2, _Trivial>
|
||||
::copy(__first, __last, __result);
|
||||
}
|
||||
|
||||
template <typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
__copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
|
||||
_BI2 __result, __true_type)
|
||||
{ return _BI2(__copy_backward_aux(__first, __last, __result.base())); }
|
||||
|
||||
template <typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
__copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
|
||||
_BI2 __result, __false_type)
|
||||
{ return __copy_backward_aux(__first, __last, __result); }
|
||||
|
||||
template <typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
__copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
|
||||
_BI2 __result, __true_type)
|
||||
{
|
||||
typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
|
||||
return __copy_backward_output_normal_iterator(__first.base(), __last.base(),
|
||||
__result, __Normal());
|
||||
}
|
||||
|
||||
template <typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
__copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
|
||||
_BI2 __result, __false_type)
|
||||
{
|
||||
typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
|
||||
return __copy_backward_output_normal_iterator(__first, __last, __result,
|
||||
__Normal());
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copies the range [first,last) into result.
|
||||
* @param first An input iterator.
|
||||
* @param last An input iterator.
|
||||
* @param result An output iterator.
|
||||
* @return result - (first - last)
|
||||
*
|
||||
* The function has the same effect as copy, but starts at the end of the
|
||||
* range and works its way to the start, returning the start of the result.
|
||||
* This inline function will boil down to a call to @c memmove whenever
|
||||
* possible. Failing that, if random access iterators are passed, then the
|
||||
* loop count will be known (and therefore a candidate for compiler
|
||||
* optimizations such as unrolling).
|
||||
*/
|
||||
template <typename _BI1, typename _BI2>
|
||||
inline _BI2
|
||||
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_BidirectionalIteratorConcept<_BI1>)
|
||||
__glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
|
||||
__glibcpp_function_requires(_ConvertibleConcept<
|
||||
typename iterator_traits<_BI1>::value_type,
|
||||
typename iterator_traits<_BI2>::value_type>)
|
||||
|
||||
typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
|
||||
return __copy_backward_input_normal_iterator(__first, __last, __result,
|
||||
__Normal());
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------
|
||||
// fill and fill_n
|
||||
|
||||
|
||||
/**
|
||||
* @brief Fills the range [first,last) with copies of value.
|
||||
* @param first A forward iterator.
|
||||
* @param last A forward iterator.
|
||||
* @param value A reference-to-const of arbitrary type.
|
||||
* @return Nothing.
|
||||
*
|
||||
* This function fills a range with copies of the same value. For one-byte
|
||||
* types filling contiguous areas of memory, this becomes an inline call to
|
||||
* @c memset.
|
||||
*/
|
||||
template<typename _ForwardIter, typename _Tp>
|
||||
void
|
||||
fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
|
||||
|
||||
for ( ; __first != __last; ++__first)
|
||||
*__first = __value;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Fills the range [first,first+n) with copies of value.
|
||||
* @param first An output iterator.
|
||||
* @param n The count of copies to perform.
|
||||
* @param value A reference-to-const of arbitrary type.
|
||||
* @return The iterator at first+n.
|
||||
*
|
||||
* This function fills a range with copies of the same value. For one-byte
|
||||
* types filling contiguous areas of memory, this becomes an inline call to
|
||||
* @c memset.
|
||||
*/
|
||||
template<typename _OutputIter, typename _Size, typename _Tp>
|
||||
_OutputIter
|
||||
fill_n(_OutputIter __first, _Size __n, const _Tp& __value)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,_Tp>)
|
||||
|
||||
for ( ; __n > 0; --__n, ++__first)
|
||||
*__first = __value;
|
||||
return __first;
|
||||
}
|
||||
|
||||
// Specialization: for one-byte types we can use memset.
|
||||
|
||||
inline void
|
||||
fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
|
||||
{
|
||||
unsigned char __tmp = __c;
|
||||
memset(__first, __tmp, __last - __first);
|
||||
}
|
||||
|
||||
inline void
|
||||
fill(signed char* __first, signed char* __last, const signed char& __c)
|
||||
{
|
||||
signed char __tmp = __c;
|
||||
memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
|
||||
}
|
||||
|
||||
inline void
|
||||
fill(char* __first, char* __last, const char& __c)
|
||||
{
|
||||
char __tmp = __c;
|
||||
memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
|
||||
}
|
||||
|
||||
template<typename _Size>
|
||||
inline unsigned char*
|
||||
fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
|
||||
{
|
||||
fill(__first, __first + __n, __c);
|
||||
return __first + __n;
|
||||
}
|
||||
|
||||
template<typename _Size>
|
||||
inline signed char*
|
||||
fill_n(char* __first, _Size __n, const signed char& __c)
|
||||
{
|
||||
fill(__first, __first + __n, __c);
|
||||
return __first + __n;
|
||||
}
|
||||
|
||||
template<typename _Size>
|
||||
inline char*
|
||||
fill_n(char* __first, _Size __n, const char& __c)
|
||||
{
|
||||
fill(__first, __first + __n, __c);
|
||||
return __first + __n;
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------
|
||||
// equal and mismatch
|
||||
|
||||
/**
|
||||
* @brief Finds the places in ranges which don't match.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @return A pair of iterators pointing to the first mismatch.
|
||||
*
|
||||
* This compares the elements of two ranges using @c == and returns a pair
|
||||
* of iterators. The first iterator points into the first range, the
|
||||
* second iterator points into the second range, and the elements pointed
|
||||
* to by the iterators are not equal.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2>
|
||||
pair<_InputIter1, _InputIter2>
|
||||
mismatch(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
__glibcpp_function_requires(_EqualityComparableConcept<
|
||||
typename iterator_traits<_InputIter1>::value_type>)
|
||||
__glibcpp_function_requires(_EqualityComparableConcept<
|
||||
typename iterator_traits<_InputIter2>::value_type>)
|
||||
|
||||
while (__first1 != __last1 && *__first1 == *__first2) {
|
||||
++__first1;
|
||||
++__first2;
|
||||
}
|
||||
return pair<_InputIter1, _InputIter2>(__first1, __first2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds the places in ranges which don't match.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @param binary_pred A binary predicate @link s20_3_1_base functor@endlink.
|
||||
* @return A pair of iterators pointing to the first mismatch.
|
||||
*
|
||||
* This compares the elements of two ranges using the binary_pred
|
||||
* parameter, and returns a pair
|
||||
* of iterators. The first iterator points into the first range, the
|
||||
* second iterator points into the second range, and the elements pointed
|
||||
* to by the iterators are not equal.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
|
||||
pair<_InputIter1, _InputIter2>
|
||||
mismatch(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2,
|
||||
_BinaryPredicate __binary_pred)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
|
||||
while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
|
||||
++__first1;
|
||||
++__first2;
|
||||
}
|
||||
return pair<_InputIter1, _InputIter2>(__first1, __first2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Tests a range for element-wise equality.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @return A boolean true or false.
|
||||
*
|
||||
* This compares the elements of two ranges using @c == and returns true or
|
||||
* false depending on whether all of the corresponding elements of the
|
||||
* ranges are equal.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2>
|
||||
inline bool
|
||||
equal(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
__glibcpp_function_requires(_EqualOpConcept<
|
||||
typename iterator_traits<_InputIter1>::value_type,
|
||||
typename iterator_traits<_InputIter2>::value_type>)
|
||||
|
||||
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||||
if (!(*__first1 == *__first2))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Tests a range for element-wise equality.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @param binary_pred A binary predicate @link s20_3_1_base functor@endlink.
|
||||
* @return A boolean true or false.
|
||||
*
|
||||
* This compares the elements of two ranges using the binary_pred
|
||||
* parameter, and returns true or
|
||||
* false depending on whether all of the corresponding elements of the
|
||||
* ranges are equal.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2, typename _BinaryPredicate>
|
||||
inline bool
|
||||
equal(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2,
|
||||
_BinaryPredicate __binary_pred)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
|
||||
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||||
if (!__binary_pred(*__first1, *__first2))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
//--------------------------------------------------
|
||||
// lexicographical_compare
|
||||
|
||||
/**
|
||||
* @brief Performs "dictionary" comparison on ranges.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @param last2 An input iterator.
|
||||
* @return A boolean true or false.
|
||||
*
|
||||
* "Returns true if the sequence of elements defined by the range
|
||||
* [first1,last1) is lexicographically less than the sequence of elements
|
||||
* defined by the range [first2,last2). Returns false otherwise."
|
||||
* (Quoted from [25.3.8]/1.) If the iterators are all character pointers,
|
||||
* then this is an inline call to @c memcmp.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2>
|
||||
bool
|
||||
lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2, _InputIter2 __last2)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<
|
||||
typename iterator_traits<_InputIter1>::value_type>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<
|
||||
typename iterator_traits<_InputIter2>::value_type>)
|
||||
|
||||
for ( ; __first1 != __last1 && __first2 != __last2
|
||||
; ++__first1, ++__first2) {
|
||||
if (*__first1 < *__first2)
|
||||
return true;
|
||||
if (*__first2 < *__first1)
|
||||
return false;
|
||||
}
|
||||
return __first1 == __last1 && __first2 != __last2;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Performs "dictionary" comparison on ranges.
|
||||
* @param first1 An input iterator.
|
||||
* @param last1 An input iterator.
|
||||
* @param first2 An input iterator.
|
||||
* @param last2 An input iterator.
|
||||
* @param comp A @link s20_3_3_comparisons comparison functor@endlink.
|
||||
* @return A boolean true or false.
|
||||
*
|
||||
* The same as the four-parameter @c lexigraphical_compare, but uses the
|
||||
* comp parameter instead of @c <.
|
||||
*/
|
||||
template<typename _InputIter1, typename _InputIter2, typename _Compare>
|
||||
bool
|
||||
lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2, _InputIter2 __last2,
|
||||
_Compare __comp)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter2>)
|
||||
|
||||
for ( ; __first1 != __last1 && __first2 != __last2
|
||||
; ++__first1, ++__first2) {
|
||||
if (__comp(*__first1, *__first2))
|
||||
return true;
|
||||
if (__comp(*__first2, *__first1))
|
||||
return false;
|
||||
}
|
||||
return __first1 == __last1 && __first2 != __last2;
|
||||
}
|
||||
|
||||
inline bool
|
||||
lexicographical_compare(const unsigned char* __first1, const unsigned char* __last1,
|
||||
const unsigned char* __first2, const unsigned char* __last2)
|
||||
{
|
||||
const size_t __len1 = __last1 - __first1;
|
||||
const size_t __len2 = __last2 - __first2;
|
||||
const int __result = memcmp(__first1, __first2, min(__len1, __len2));
|
||||
return __result != 0 ? __result < 0 : __len1 < __len2;
|
||||
}
|
||||
|
||||
inline bool
|
||||
lexicographical_compare(const char* __first1, const char* __last1,
|
||||
const char* __first2, const char* __last2)
|
||||
{
|
||||
#if CHAR_MAX == SCHAR_MAX
|
||||
return lexicographical_compare((const signed char*) __first1,
|
||||
(const signed char*) __last1,
|
||||
(const signed char*) __first2,
|
||||
(const signed char*) __last2);
|
||||
#else /* CHAR_MAX == SCHAR_MAX */
|
||||
return lexicographical_compare((const unsigned char*) __first1,
|
||||
(const unsigned char*) __last1,
|
||||
(const unsigned char*) __first2,
|
||||
(const unsigned char*) __last2);
|
||||
#endif /* CHAR_MAX == SCHAR_MAX */
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_ALGOBASE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
984
TBE/MinGW/include/c++/3.2.3/bits/stl_alloc.h
Normal file
984
TBE/MinGW/include/c++/3.2.3/bits/stl_alloc.h
Normal file
@@ -0,0 +1,984 @@
|
||||
// Allocators -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996-1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_alloc.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_ALLOC_H
|
||||
#define __GLIBCPP_INTERNAL_ALLOC_H
|
||||
|
||||
/**
|
||||
* @defgroup Allocators Memory Allocators
|
||||
* @if maint
|
||||
* stl_alloc.h implements some node allocators. These are NOT the same as
|
||||
* allocators in the C++ standard, nor in the original H-P STL. They do not
|
||||
* encapsulate different pointer types; we assume that there is only one
|
||||
* pointer type. The C++ standard allocators are intended to allocate
|
||||
* individual objects, not pools or arenas.
|
||||
*
|
||||
* In this file allocators are of two different styles: "standard" and
|
||||
* "SGI" (quotes included). "Standard" allocators conform to 20.4. "SGI"
|
||||
* allocators differ in AT LEAST the following ways (add to this list as you
|
||||
* discover them):
|
||||
*
|
||||
* - "Standard" allocate() takes two parameters (n_count,hint=0) but "SGI"
|
||||
* allocate() takes one paramter (n_size).
|
||||
* - Likewise, "standard" deallocate()'s argument is a count, but in "SGI"
|
||||
* is a byte size.
|
||||
* - max_size(), construct(), and destroy() are missing in "SGI" allocators.
|
||||
* - reallocate(p,oldsz,newsz) is added in "SGI", and behaves as
|
||||
* if p=realloc(p,newsz).
|
||||
*
|
||||
* "SGI" allocators may be wrapped in __allocator to convert the interface
|
||||
* into a "standard" one.
|
||||
* @endif
|
||||
*
|
||||
* @note The @c reallocate member functions have been deprecated for 3.2
|
||||
* and will be removed in 3.4. You must define @c _GLIBCPP_DEPRECATED
|
||||
* to make this visible in 3.2; see c++config.h.
|
||||
*
|
||||
* The canonical description of these classes is in docs/html/ext/howto.html
|
||||
* or online at http://gcc.gnu.org/onlinedocs/libstdc++/ext/howto.html#3
|
||||
*/
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
#include <bits/functexcept.h> // For __throw_bad_alloc
|
||||
#include <bits/stl_threads.h>
|
||||
|
||||
#include <bits/atomicity.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* @if maint
|
||||
* A new-based allocator, as required by the standard. Allocation and
|
||||
* deallocation forward to global new and delete. "SGI" style, minus
|
||||
* reallocate().
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
class __new_alloc
|
||||
{
|
||||
public:
|
||||
static void*
|
||||
allocate(size_t __n)
|
||||
{ return ::operator new(__n); }
|
||||
|
||||
static void
|
||||
deallocate(void* __p, size_t)
|
||||
{ ::operator delete(__p); }
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* A malloc-based allocator. Typically slower than the
|
||||
* __default_alloc_template (below). Typically thread-safe and more
|
||||
* storage efficient. The template argument is unused and is only present
|
||||
* to permit multiple instantiations (but see __default_alloc_template
|
||||
* for caveats). "SGI" style, plus __set_malloc_handler for OOM conditions.
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<int __inst>
|
||||
class __malloc_alloc_template
|
||||
{
|
||||
private:
|
||||
static void* _S_oom_malloc(size_t);
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
static void* _S_oom_realloc(void*, size_t);
|
||||
|
||||
static void (* __malloc_alloc_oom_handler)();
|
||||
|
||||
public:
|
||||
static void*
|
||||
allocate(size_t __n)
|
||||
{
|
||||
void* __result = malloc(__n);
|
||||
if (__builtin_expect(__result == 0, 0))
|
||||
__result = _S_oom_malloc(__n);
|
||||
return __result;
|
||||
}
|
||||
|
||||
static void
|
||||
deallocate(void* __p, size_t /* __n */)
|
||||
{ free(__p); }
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
static void*
|
||||
reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
|
||||
{
|
||||
void* __result = realloc(__p, __new_sz);
|
||||
if (__builtin_expect(__result == 0, 0))
|
||||
__result = _S_oom_realloc(__p, __new_sz);
|
||||
return __result;
|
||||
}
|
||||
|
||||
static void (* __set_malloc_handler(void (*__f)()))()
|
||||
{
|
||||
void (* __old)() = __malloc_alloc_oom_handler;
|
||||
__malloc_alloc_oom_handler = __f;
|
||||
return __old;
|
||||
}
|
||||
};
|
||||
|
||||
// malloc_alloc out-of-memory handling
|
||||
template<int __inst>
|
||||
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
|
||||
|
||||
template<int __inst>
|
||||
void*
|
||||
__malloc_alloc_template<__inst>::
|
||||
_S_oom_malloc(size_t __n)
|
||||
{
|
||||
void (* __my_malloc_handler)();
|
||||
void* __result;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
__my_malloc_handler = __malloc_alloc_oom_handler;
|
||||
if (__builtin_expect(__my_malloc_handler == 0, 0))
|
||||
__throw_bad_alloc();
|
||||
(*__my_malloc_handler)();
|
||||
__result = malloc(__n);
|
||||
if (__result)
|
||||
return __result;
|
||||
}
|
||||
}
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
template<int __inst>
|
||||
void*
|
||||
__malloc_alloc_template<__inst>::
|
||||
_S_oom_realloc(void* __p, size_t __n)
|
||||
{
|
||||
void (* __my_malloc_handler)();
|
||||
void* __result;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
__my_malloc_handler = __malloc_alloc_oom_handler;
|
||||
if (__builtin_expect(__my_malloc_handler == 0, 0))
|
||||
__throw_bad_alloc();
|
||||
(*__my_malloc_handler)();
|
||||
__result = realloc(__p, __n);
|
||||
if (__result)
|
||||
return __result;
|
||||
}
|
||||
}
|
||||
|
||||
// Should not be referenced within the library anymore.
|
||||
typedef __new_alloc __mem_interface;
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* This is used primarily (only?) in _Alloc_traits and other places to
|
||||
* help provide the _Alloc_type typedef. All it does is forward the
|
||||
* requests after some minimal checking.
|
||||
*
|
||||
* This is neither "standard"-conforming nor "SGI". The _Alloc parameter
|
||||
* must be "SGI" style.
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<typename _Tp, typename _Alloc>
|
||||
class __simple_alloc
|
||||
{
|
||||
public:
|
||||
static _Tp*
|
||||
allocate(size_t __n)
|
||||
{
|
||||
_Tp* __ret = 0;
|
||||
if (__n)
|
||||
__ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
|
||||
return __ret;
|
||||
}
|
||||
|
||||
static _Tp*
|
||||
allocate()
|
||||
{ return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
|
||||
|
||||
static void
|
||||
deallocate(_Tp* __p, size_t __n)
|
||||
{ if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
|
||||
|
||||
static void
|
||||
deallocate(_Tp* __p)
|
||||
{ _Alloc::deallocate(__p, sizeof (_Tp)); }
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* An adaptor for an underlying allocator (_Alloc) to check the size
|
||||
* arguments for debugging. Errors are reported using assert; these
|
||||
* checks can be disabled via NDEBUG, but the space penalty is still
|
||||
* paid, therefore it is far better to just use the underlying allocator
|
||||
* by itelf when no checking is desired.
|
||||
*
|
||||
* "There is some evidence that this can confuse Purify." - SGI comment
|
||||
*
|
||||
* This adaptor is "SGI" style. The _Alloc parameter must also be "SGI".
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<typename _Alloc>
|
||||
class __debug_alloc
|
||||
{
|
||||
private:
|
||||
// Size of space used to store size. Note that this must be
|
||||
// large enough to preserve alignment.
|
||||
enum {_S_extra = 8};
|
||||
|
||||
public:
|
||||
static void*
|
||||
allocate(size_t __n)
|
||||
{
|
||||
char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra);
|
||||
*(size_t*)__result = __n;
|
||||
return __result + (int) _S_extra;
|
||||
}
|
||||
|
||||
static void
|
||||
deallocate(void* __p, size_t __n)
|
||||
{
|
||||
char* __real_p = (char*)__p - (int) _S_extra;
|
||||
assert(*(size_t*)__real_p == __n);
|
||||
_Alloc::deallocate(__real_p, __n + (int) _S_extra);
|
||||
}
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
static void*
|
||||
reallocate(void* __p, size_t __old_sz, size_t __new_sz)
|
||||
{
|
||||
char* __real_p = (char*)__p - (int) _S_extra;
|
||||
assert(*(size_t*)__real_p == __old_sz);
|
||||
char* __result = (char*) _Alloc::reallocate(__real_p,
|
||||
__old_sz + (int) _S_extra,
|
||||
__new_sz + (int) _S_extra);
|
||||
*(size_t*)__result = __new_sz;
|
||||
return __result + (int) _S_extra;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Default node allocator. "SGI" style. Uses various allocators to
|
||||
* fulfill underlying requests (and makes as few requests as possible
|
||||
* when in default high-speed pool mode).
|
||||
*
|
||||
* Important implementation properties:
|
||||
* 0. If globally mandated, then allocate objects from __new_alloc
|
||||
* 1. If the clients request an object of size > _MAX_BYTES, the resulting
|
||||
* object will be obtained directly from __new_alloc
|
||||
* 2. In all other cases, we allocate an object of size exactly
|
||||
* _S_round_up(requested_size). Thus the client has enough size
|
||||
* information that we can return the object to the proper free list
|
||||
* without permanently losing part of the object.
|
||||
*
|
||||
* The first template parameter specifies whether more than one thread may
|
||||
* use this allocator. It is safe to allocate an object from one instance
|
||||
* of a default_alloc and deallocate it with another one. This effectively
|
||||
* transfers its ownership to the second one. This may have undesirable
|
||||
* effects on reference locality.
|
||||
*
|
||||
* The second parameter is unused and serves only to allow the creation of
|
||||
* multiple default_alloc instances. Note that containers built on different
|
||||
* allocator instances have different types, limiting the utility of this
|
||||
* approach. If you do not wish to share the free lists with the main
|
||||
* default_alloc instance, instantiate this with a non-zero __inst.
|
||||
*
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<bool __threads, int __inst>
|
||||
class __default_alloc_template
|
||||
{
|
||||
private:
|
||||
enum {_ALIGN = 8};
|
||||
enum {_MAX_BYTES = 128};
|
||||
enum {_NFREELISTS = _MAX_BYTES / _ALIGN};
|
||||
|
||||
union _Obj
|
||||
{
|
||||
union _Obj* _M_free_list_link;
|
||||
char _M_client_data[1]; // The client sees this.
|
||||
};
|
||||
|
||||
static _Obj* volatile _S_free_list[_NFREELISTS];
|
||||
|
||||
// Chunk allocation state.
|
||||
static char* _S_start_free;
|
||||
static char* _S_end_free;
|
||||
static size_t _S_heap_size;
|
||||
|
||||
static _STL_mutex_lock _S_node_allocator_lock;
|
||||
|
||||
static size_t
|
||||
_S_round_up(size_t __bytes)
|
||||
{ return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }
|
||||
|
||||
static size_t
|
||||
_S_freelist_index(size_t __bytes)
|
||||
{ return (((__bytes) + (size_t)_ALIGN - 1)/(size_t)_ALIGN - 1); }
|
||||
|
||||
// Returns an object of size __n, and optionally adds to size __n
|
||||
// free list.
|
||||
static void*
|
||||
_S_refill(size_t __n);
|
||||
|
||||
// Allocates a chunk for nobjs of size size. nobjs may be reduced
|
||||
// if it is inconvenient to allocate the requested number.
|
||||
static char*
|
||||
_S_chunk_alloc(size_t __size, int& __nobjs);
|
||||
|
||||
// It would be nice to use _STL_auto_lock here. But we need a
|
||||
// test whether threads are in use.
|
||||
struct _Lock
|
||||
{
|
||||
_Lock() { if (__threads) _S_node_allocator_lock._M_acquire_lock(); }
|
||||
~_Lock() { if (__threads) _S_node_allocator_lock._M_release_lock(); }
|
||||
} __attribute__ ((__unused__));
|
||||
friend struct _Lock;
|
||||
|
||||
static _Atomic_word _S_force_new;
|
||||
|
||||
public:
|
||||
// __n must be > 0
|
||||
static void*
|
||||
allocate(size_t __n)
|
||||
{
|
||||
void* __ret = 0;
|
||||
|
||||
// If there is a race through here, assume answer from getenv
|
||||
// will resolve in same direction. Inspired by techniques
|
||||
// to efficiently support threading found in basic_string.h.
|
||||
if (_S_force_new == 0)
|
||||
{
|
||||
if (getenv("GLIBCPP_FORCE_NEW"))
|
||||
__atomic_add(&_S_force_new, 1);
|
||||
else
|
||||
__atomic_add(&_S_force_new, -1);
|
||||
// Trust but verify...
|
||||
assert(_S_force_new != 0);
|
||||
}
|
||||
|
||||
if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
|
||||
__ret = __new_alloc::allocate(__n);
|
||||
else
|
||||
{
|
||||
_Obj* volatile* __my_free_list = _S_free_list
|
||||
+ _S_freelist_index(__n);
|
||||
// Acquire the lock here with a constructor call. This
|
||||
// ensures that it is released in exit or during stack
|
||||
// unwinding.
|
||||
_Lock __lock_instance;
|
||||
_Obj* __restrict__ __result = *__my_free_list;
|
||||
if (__builtin_expect(__result == 0, 0))
|
||||
__ret = _S_refill(_S_round_up(__n));
|
||||
else
|
||||
{
|
||||
*__my_free_list = __result -> _M_free_list_link;
|
||||
__ret = __result;
|
||||
}
|
||||
if (__builtin_expect(__ret == 0, 0))
|
||||
__throw_bad_alloc();
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// __p may not be 0
|
||||
static void
|
||||
deallocate(void* __p, size_t __n)
|
||||
{
|
||||
if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
|
||||
__new_alloc::deallocate(__p, __n);
|
||||
else
|
||||
{
|
||||
_Obj* volatile* __my_free_list = _S_free_list
|
||||
+ _S_freelist_index(__n);
|
||||
_Obj* __q = (_Obj*)__p;
|
||||
|
||||
// Acquire the lock here with a constructor call. This
|
||||
// ensures that it is released in exit or during stack
|
||||
// unwinding.
|
||||
_Lock __lock_instance;
|
||||
__q -> _M_free_list_link = *__my_free_list;
|
||||
*__my_free_list = __q;
|
||||
}
|
||||
}
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
static void*
|
||||
reallocate(void* __p, size_t __old_sz, size_t __new_sz);
|
||||
};
|
||||
|
||||
template<bool __threads, int __inst> _Atomic_word
|
||||
__default_alloc_template<__threads, __inst>::_S_force_new = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
inline bool
|
||||
operator==(const __default_alloc_template<__threads,__inst>&,
|
||||
const __default_alloc_template<__threads,__inst>&)
|
||||
{ return true; }
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
inline bool
|
||||
operator!=(const __default_alloc_template<__threads,__inst>&,
|
||||
const __default_alloc_template<__threads,__inst>&)
|
||||
{ return false; }
|
||||
|
||||
|
||||
// We allocate memory in large chunks in order to avoid fragmenting the
|
||||
// heap too much. We assume that __size is properly aligned. We hold
|
||||
// the allocation lock.
|
||||
template<bool __threads, int __inst>
|
||||
char*
|
||||
__default_alloc_template<__threads, __inst>::
|
||||
_S_chunk_alloc(size_t __size, int& __nobjs)
|
||||
{
|
||||
char* __result;
|
||||
size_t __total_bytes = __size * __nobjs;
|
||||
size_t __bytes_left = _S_end_free - _S_start_free;
|
||||
|
||||
if (__bytes_left >= __total_bytes)
|
||||
{
|
||||
__result = _S_start_free;
|
||||
_S_start_free += __total_bytes;
|
||||
return __result ;
|
||||
}
|
||||
else if (__bytes_left >= __size)
|
||||
{
|
||||
__nobjs = (int)(__bytes_left/__size);
|
||||
__total_bytes = __size * __nobjs;
|
||||
__result = _S_start_free;
|
||||
_S_start_free += __total_bytes;
|
||||
return __result;
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t __bytes_to_get =
|
||||
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
|
||||
// Try to make use of the left-over piece.
|
||||
if (__bytes_left > 0)
|
||||
{
|
||||
_Obj* volatile* __my_free_list =
|
||||
_S_free_list + _S_freelist_index(__bytes_left);
|
||||
|
||||
((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
|
||||
*__my_free_list = (_Obj*)_S_start_free;
|
||||
}
|
||||
_S_start_free = (char*) __new_alloc::allocate(__bytes_to_get);
|
||||
if (_S_start_free == 0)
|
||||
{
|
||||
size_t __i;
|
||||
_Obj* volatile* __my_free_list;
|
||||
_Obj* __p;
|
||||
// Try to make do with what we have. That can't hurt. We
|
||||
// do not try smaller requests, since that tends to result
|
||||
// in disaster on multi-process machines.
|
||||
__i = __size;
|
||||
for (; __i <= (size_t) _MAX_BYTES; __i += (size_t) _ALIGN)
|
||||
{
|
||||
__my_free_list = _S_free_list + _S_freelist_index(__i);
|
||||
__p = *__my_free_list;
|
||||
if (__p != 0)
|
||||
{
|
||||
*__my_free_list = __p -> _M_free_list_link;
|
||||
_S_start_free = (char*)__p;
|
||||
_S_end_free = _S_start_free + __i;
|
||||
return _S_chunk_alloc(__size, __nobjs);
|
||||
// Any leftover piece will eventually make it to the
|
||||
// right free list.
|
||||
}
|
||||
}
|
||||
_S_end_free = 0; // In case of exception.
|
||||
_S_start_free = (char*)__new_alloc::allocate(__bytes_to_get);
|
||||
// This should either throw an exception or remedy the situation.
|
||||
// Thus we assume it succeeded.
|
||||
}
|
||||
_S_heap_size += __bytes_to_get;
|
||||
_S_end_free = _S_start_free + __bytes_to_get;
|
||||
return _S_chunk_alloc(__size, __nobjs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Returns an object of size __n, and optionally adds to "size
|
||||
// __n"'s free list. We assume that __n is properly aligned. We
|
||||
// hold the allocation lock.
|
||||
template<bool __threads, int __inst>
|
||||
void*
|
||||
__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
|
||||
{
|
||||
int __nobjs = 20;
|
||||
char* __chunk = _S_chunk_alloc(__n, __nobjs);
|
||||
_Obj* volatile* __my_free_list;
|
||||
_Obj* __result;
|
||||
_Obj* __current_obj;
|
||||
_Obj* __next_obj;
|
||||
int __i;
|
||||
|
||||
if (1 == __nobjs)
|
||||
return __chunk;
|
||||
__my_free_list = _S_free_list + _S_freelist_index(__n);
|
||||
|
||||
// Build free list in chunk.
|
||||
__result = (_Obj*)__chunk;
|
||||
*__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
|
||||
for (__i = 1; ; __i++)
|
||||
{
|
||||
__current_obj = __next_obj;
|
||||
__next_obj = (_Obj*)((char*)__next_obj + __n);
|
||||
if (__nobjs - 1 == __i)
|
||||
{
|
||||
__current_obj -> _M_free_list_link = 0;
|
||||
break;
|
||||
}
|
||||
else
|
||||
__current_obj -> _M_free_list_link = __next_obj;
|
||||
}
|
||||
return __result;
|
||||
}
|
||||
|
||||
|
||||
// _GLIBCPP_DEPRECATED
|
||||
template<bool threads, int inst>
|
||||
void*
|
||||
__default_alloc_template<threads, inst>::
|
||||
reallocate(void* __p, size_t __old_sz, size_t __new_sz)
|
||||
{
|
||||
void* __result;
|
||||
size_t __copy_sz;
|
||||
|
||||
if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES)
|
||||
return(realloc(__p, __new_sz));
|
||||
if (_S_round_up(__old_sz) == _S_round_up(__new_sz))
|
||||
return(__p);
|
||||
__result = allocate(__new_sz);
|
||||
__copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
|
||||
memcpy(__result, __p, __copy_sz);
|
||||
deallocate(__p, __old_sz);
|
||||
return __result;
|
||||
}
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
_STL_mutex_lock
|
||||
__default_alloc_template<__threads,__inst>::_S_node_allocator_lock
|
||||
__STL_MUTEX_INITIALIZER;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
char* __default_alloc_template<__threads,__inst>::_S_start_free = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
char* __default_alloc_template<__threads,__inst>::_S_end_free = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
size_t __default_alloc_template<__threads,__inst>::_S_heap_size = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
typename __default_alloc_template<__threads,__inst>::_Obj* volatile
|
||||
__default_alloc_template<__threads,__inst>::_S_free_list[_NFREELISTS];
|
||||
|
||||
typedef __default_alloc_template<true,0> __alloc;
|
||||
typedef __default_alloc_template<false,0> __single_client_alloc;
|
||||
|
||||
|
||||
/**
|
||||
* @brief The "standard" allocator, as per [20.4].
|
||||
*
|
||||
* The private _Alloc is "SGI" style. (See comments at the top
|
||||
* of stl_alloc.h.)
|
||||
*
|
||||
* The underlying allocator behaves as follows.
|
||||
* - __default_alloc_template is used via two typedefs
|
||||
* - "__single_client_alloc" typedef does no locking for threads
|
||||
* - "__alloc" typedef is threadsafe via the locks
|
||||
* - __new_alloc is used for memory requests
|
||||
*
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<typename _Tp>
|
||||
class allocator
|
||||
{
|
||||
typedef __alloc _Alloc; // The underlying allocator.
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef const _Tp* const_pointer;
|
||||
typedef _Tp& reference;
|
||||
typedef const _Tp& const_reference;
|
||||
typedef _Tp value_type;
|
||||
|
||||
template<typename _Tp1>
|
||||
struct rebind
|
||||
{ typedef allocator<_Tp1> other; };
|
||||
|
||||
allocator() throw() {}
|
||||
allocator(const allocator&) throw() {}
|
||||
template<typename _Tp1>
|
||||
allocator(const allocator<_Tp1>&) throw() {}
|
||||
~allocator() throw() {}
|
||||
|
||||
pointer
|
||||
address(reference __x) const { return &__x; }
|
||||
|
||||
const_pointer
|
||||
address(const_reference __x) const { return &__x; }
|
||||
|
||||
// NB: __n is permitted to be 0. The C++ standard says nothing
|
||||
// about what the return value is when __n == 0.
|
||||
_Tp*
|
||||
allocate(size_type __n, const void* = 0)
|
||||
{
|
||||
_Tp* __ret = 0;
|
||||
if (__n)
|
||||
{
|
||||
if (__n <= this->max_size())
|
||||
__ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
|
||||
else
|
||||
__throw_bad_alloc();
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// __p is not permitted to be a null pointer.
|
||||
void
|
||||
deallocate(pointer __p, size_type __n)
|
||||
{ _Alloc::deallocate(__p, __n * sizeof(_Tp)); }
|
||||
|
||||
size_type
|
||||
max_size() const throw() { return size_t(-1) / sizeof(_Tp); }
|
||||
|
||||
void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
|
||||
void destroy(pointer __p) { __p->~_Tp(); }
|
||||
};
|
||||
|
||||
template<>
|
||||
class allocator<void>
|
||||
{
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef void* pointer;
|
||||
typedef const void* const_pointer;
|
||||
typedef void value_type;
|
||||
|
||||
template<typename _Tp1>
|
||||
struct rebind
|
||||
{ typedef allocator<_Tp1> other; };
|
||||
};
|
||||
|
||||
|
||||
template<typename _T1, typename _T2>
|
||||
inline bool
|
||||
operator==(const allocator<_T1>&, const allocator<_T2>&)
|
||||
{ return true; }
|
||||
|
||||
template<typename _T1, typename _T2>
|
||||
inline bool
|
||||
operator!=(const allocator<_T1>&, const allocator<_T2>&)
|
||||
{ return false; }
|
||||
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Allocator adaptor to turn an "SGI" style allocator (e.g.,
|
||||
* __alloc, __malloc_alloc_template) into a "standard" conforming
|
||||
* allocator. Note that this adaptor does *not* assume that all
|
||||
* objects of the underlying alloc class are identical, nor does it
|
||||
* assume that all of the underlying alloc's member functions are
|
||||
* static member functions. Note, also, that __allocator<_Tp,
|
||||
* __alloc> is essentially the same thing as allocator<_Tp>.
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<typename _Tp, typename _Alloc>
|
||||
struct __allocator
|
||||
{
|
||||
_Alloc __underlying_alloc;
|
||||
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef const _Tp* const_pointer;
|
||||
typedef _Tp& reference;
|
||||
typedef const _Tp& const_reference;
|
||||
typedef _Tp value_type;
|
||||
|
||||
template<typename _Tp1>
|
||||
struct rebind
|
||||
{ typedef __allocator<_Tp1, _Alloc> other; };
|
||||
|
||||
__allocator() throw() {}
|
||||
__allocator(const __allocator& __a) throw()
|
||||
: __underlying_alloc(__a.__underlying_alloc) {}
|
||||
|
||||
template<typename _Tp1>
|
||||
__allocator(const __allocator<_Tp1, _Alloc>& __a) throw()
|
||||
: __underlying_alloc(__a.__underlying_alloc) {}
|
||||
|
||||
~__allocator() throw() {}
|
||||
|
||||
pointer
|
||||
address(reference __x) const { return &__x; }
|
||||
|
||||
const_pointer
|
||||
address(const_reference __x) const { return &__x; }
|
||||
|
||||
// NB: __n is permitted to be 0. The C++ standard says nothing
|
||||
// about what the return value is when __n == 0.
|
||||
_Tp*
|
||||
allocate(size_type __n, const void* = 0)
|
||||
{
|
||||
_Tp* __ret = 0;
|
||||
if (__n)
|
||||
__ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// __p is not permitted to be a null pointer.
|
||||
void
|
||||
deallocate(pointer __p, size_type __n)
|
||||
{ __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }
|
||||
|
||||
size_type
|
||||
max_size() const throw() { return size_t(-1) / sizeof(_Tp); }
|
||||
|
||||
void
|
||||
construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
|
||||
|
||||
void
|
||||
destroy(pointer __p) { __p->~_Tp(); }
|
||||
};
|
||||
|
||||
template<typename _Alloc>
|
||||
struct __allocator<void, _Alloc>
|
||||
{
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef void* pointer;
|
||||
typedef const void* const_pointer;
|
||||
typedef void value_type;
|
||||
|
||||
template<typename _Tp1>
|
||||
struct rebind
|
||||
{ typedef __allocator<_Tp1, _Alloc> other; };
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator==(const __allocator<_Tp,_Alloc>& __a1,
|
||||
const __allocator<_Tp,_Alloc>& __a2)
|
||||
{ return __a1.__underlying_alloc == __a2.__underlying_alloc; }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator!=(const __allocator<_Tp, _Alloc>& __a1,
|
||||
const __allocator<_Tp, _Alloc>& __a2)
|
||||
{ return __a1.__underlying_alloc != __a2.__underlying_alloc; }
|
||||
|
||||
|
||||
//@{
|
||||
/** Comparison operators for all of the predifined SGI-style allocators.
|
||||
* This ensures that __allocator<malloc_alloc> (for example) will work
|
||||
* correctly. As required, all allocators compare equal.
|
||||
*/
|
||||
template<int inst>
|
||||
inline bool
|
||||
operator==(const __malloc_alloc_template<inst>&,
|
||||
const __malloc_alloc_template<inst>&)
|
||||
{ return true; }
|
||||
|
||||
template<int __inst>
|
||||
inline bool
|
||||
operator!=(const __malloc_alloc_template<__inst>&,
|
||||
const __malloc_alloc_template<__inst>&)
|
||||
{ return false; }
|
||||
|
||||
template<typename _Alloc>
|
||||
inline bool
|
||||
operator==(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&)
|
||||
{ return true; }
|
||||
|
||||
template<typename _Alloc>
|
||||
inline bool
|
||||
operator!=(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&)
|
||||
{ return false; }
|
||||
//@}
|
||||
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Another allocator adaptor: _Alloc_traits. This serves two purposes.
|
||||
* First, make it possible to write containers that can use either "SGI"
|
||||
* style allocators or "standard" allocators. Second, provide a mechanism
|
||||
* so that containers can query whether or not the allocator has distinct
|
||||
* instances. If not, the container can avoid wasting a word of memory to
|
||||
* store an empty object. For examples of use, see stl_vector.h, etc, or
|
||||
* any of the other classes derived from this one.
|
||||
*
|
||||
* This adaptor uses partial specialization. The general case of
|
||||
* _Alloc_traits<_Tp, _Alloc> assumes that _Alloc is a
|
||||
* standard-conforming allocator, possibly with non-equal instances and
|
||||
* non-static members. (It still behaves correctly even if _Alloc has
|
||||
* static member and if all instances are equal. Refinements affect
|
||||
* performance, not correctness.)
|
||||
*
|
||||
* There are always two members: allocator_type, which is a standard-
|
||||
* conforming allocator type for allocating objects of type _Tp, and
|
||||
* _S_instanceless, a static const member of type bool. If
|
||||
* _S_instanceless is true, this means that there is no difference
|
||||
* between any two instances of type allocator_type. Furthermore, if
|
||||
* _S_instanceless is true, then _Alloc_traits has one additional
|
||||
* member: _Alloc_type. This type encapsulates allocation and
|
||||
* deallocation of objects of type _Tp through a static interface; it
|
||||
* has two member functions, whose signatures are
|
||||
*
|
||||
* - static _Tp* allocate(size_t)
|
||||
* - static void deallocate(_Tp*, size_t)
|
||||
*
|
||||
* The size_t parameters are "standard" style (see top of stl_alloc.h) in
|
||||
* that they take counts, not sizes.
|
||||
*
|
||||
* @endif
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
//@{
|
||||
// The fully general version.
|
||||
template<typename _Tp, typename _Allocator>
|
||||
struct _Alloc_traits
|
||||
{
|
||||
static const bool _S_instanceless = false;
|
||||
typedef typename _Allocator::template rebind<_Tp>::other allocator_type;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Allocator>
|
||||
const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;
|
||||
|
||||
/// The version for the default allocator.
|
||||
template<typename _Tp, typename _Tp1>
|
||||
struct _Alloc_traits<_Tp, allocator<_Tp1> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __alloc> _Alloc_type;
|
||||
typedef allocator<_Tp> allocator_type;
|
||||
};
|
||||
//@}
|
||||
|
||||
//@{
|
||||
/// Versions for the predefined "SGI" style allocators.
|
||||
template<typename _Tp, int __inst>
|
||||
struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
|
||||
typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
|
||||
};
|
||||
|
||||
template<typename _Tp, bool __threads, int __inst>
|
||||
struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
|
||||
_Alloc_type;
|
||||
typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
|
||||
allocator_type;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
struct _Alloc_traits<_Tp, __debug_alloc<_Alloc> >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __debug_alloc<_Alloc> > _Alloc_type;
|
||||
typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
|
||||
};
|
||||
//@}
|
||||
|
||||
//@{
|
||||
/// Versions for the __allocator adaptor used with the predefined
|
||||
/// "SGI" style allocators.
|
||||
template<typename _Tp, typename _Tp1, int __inst>
|
||||
struct _Alloc_traits<_Tp,
|
||||
__allocator<_Tp1, __malloc_alloc_template<__inst> > >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
|
||||
typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Tp1, bool __thr, int __inst>
|
||||
struct _Alloc_traits<_Tp, __allocator<_Tp1, __default_alloc_template<__thr, __inst> > >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
|
||||
_Alloc_type;
|
||||
typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
|
||||
allocator_type;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Tp1, typename _Alloc>
|
||||
struct _Alloc_traits<_Tp, __allocator<_Tp1, __debug_alloc<_Alloc> > >
|
||||
{
|
||||
static const bool _S_instanceless = true;
|
||||
typedef __simple_alloc<_Tp, __debug_alloc<_Alloc> > _Alloc_type;
|
||||
typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
|
||||
};
|
||||
//@}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class allocator<char>;
|
||||
extern template class allocator<wchar_t>;
|
||||
extern template class __default_alloc_template<true,0>;
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
728
TBE/MinGW/include/c++/3.2.3/bits/stl_bvector.h
Normal file
728
TBE/MinGW/include/c++/3.2.3/bits/stl_bvector.h
Normal file
@@ -0,0 +1,728 @@
|
||||
// bit_vector and vector<bool> specialization -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1999
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_bvector.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_BVECTOR_H
|
||||
#define __GLIBCPP_INTERNAL_BVECTOR_H
|
||||
|
||||
namespace std
|
||||
{
|
||||
typedef unsigned long _Bit_type;
|
||||
enum { _M_word_bit = int(CHAR_BIT * sizeof(_Bit_type)) };
|
||||
|
||||
struct _Bit_reference {
|
||||
|
||||
_Bit_type * _M_p;
|
||||
_Bit_type _M_mask;
|
||||
_Bit_reference(_Bit_type * __x, _Bit_type __y)
|
||||
: _M_p(__x), _M_mask(__y) {}
|
||||
|
||||
public:
|
||||
_Bit_reference() : _M_p(0), _M_mask(0) {}
|
||||
operator bool() const { return !!(*_M_p & _M_mask); }
|
||||
_Bit_reference& operator=(bool __x)
|
||||
{
|
||||
if (__x) *_M_p |= _M_mask;
|
||||
else *_M_p &= ~_M_mask;
|
||||
return *this;
|
||||
}
|
||||
_Bit_reference& operator=(const _Bit_reference& __x)
|
||||
{ return *this = bool(__x); }
|
||||
bool operator==(const _Bit_reference& __x) const
|
||||
{ return bool(*this) == bool(__x); }
|
||||
bool operator<(const _Bit_reference& __x) const
|
||||
{ return !bool(*this) && bool(__x); }
|
||||
void flip() { *_M_p ^= _M_mask; }
|
||||
};
|
||||
|
||||
inline void swap(_Bit_reference __x, _Bit_reference __y)
|
||||
{
|
||||
bool __tmp = __x;
|
||||
__x = __y;
|
||||
__y = __tmp;
|
||||
}
|
||||
|
||||
struct _Bit_iterator_base : public iterator<random_access_iterator_tag, bool>
|
||||
{
|
||||
_Bit_type * _M_p;
|
||||
unsigned int _M_offset;
|
||||
|
||||
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
|
||||
: _M_p(__x), _M_offset(__y) {}
|
||||
|
||||
void _M_bump_up() {
|
||||
if (_M_offset++ == _M_word_bit - 1) {
|
||||
_M_offset = 0;
|
||||
++_M_p;
|
||||
}
|
||||
}
|
||||
void _M_bump_down() {
|
||||
if (_M_offset-- == 0) {
|
||||
_M_offset = _M_word_bit - 1;
|
||||
--_M_p;
|
||||
}
|
||||
}
|
||||
|
||||
void _M_incr(ptrdiff_t __i) {
|
||||
difference_type __n = __i + _M_offset;
|
||||
_M_p += __n / _M_word_bit;
|
||||
__n = __n % _M_word_bit;
|
||||
if (__n < 0) {
|
||||
_M_offset = (unsigned int) __n + _M_word_bit;
|
||||
--_M_p;
|
||||
} else
|
||||
_M_offset = (unsigned int) __n;
|
||||
}
|
||||
|
||||
bool operator==(const _Bit_iterator_base& __i) const {
|
||||
return _M_p == __i._M_p && _M_offset == __i._M_offset;
|
||||
}
|
||||
bool operator<(const _Bit_iterator_base& __i) const {
|
||||
return _M_p < __i._M_p || (_M_p == __i._M_p && _M_offset < __i._M_offset);
|
||||
}
|
||||
bool operator!=(const _Bit_iterator_base& __i) const {
|
||||
return !(*this == __i);
|
||||
}
|
||||
bool operator>(const _Bit_iterator_base& __i) const {
|
||||
return __i < *this;
|
||||
}
|
||||
bool operator<=(const _Bit_iterator_base& __i) const {
|
||||
return !(__i < *this);
|
||||
}
|
||||
bool operator>=(const _Bit_iterator_base& __i) const {
|
||||
return !(*this < __i);
|
||||
}
|
||||
};
|
||||
|
||||
inline ptrdiff_t
|
||||
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
|
||||
return _M_word_bit * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset;
|
||||
}
|
||||
|
||||
|
||||
struct _Bit_iterator : public _Bit_iterator_base
|
||||
{
|
||||
typedef _Bit_reference reference;
|
||||
typedef _Bit_reference* pointer;
|
||||
typedef _Bit_iterator iterator;
|
||||
|
||||
_Bit_iterator() : _Bit_iterator_base(0, 0) {}
|
||||
_Bit_iterator(_Bit_type * __x, unsigned int __y)
|
||||
: _Bit_iterator_base(__x, __y) {}
|
||||
|
||||
reference operator*() const { return reference(_M_p, 1UL << _M_offset); }
|
||||
iterator& operator++() {
|
||||
_M_bump_up();
|
||||
return *this;
|
||||
}
|
||||
iterator operator++(int) {
|
||||
iterator __tmp = *this;
|
||||
_M_bump_up();
|
||||
return __tmp;
|
||||
}
|
||||
iterator& operator--() {
|
||||
_M_bump_down();
|
||||
return *this;
|
||||
}
|
||||
iterator operator--(int) {
|
||||
iterator __tmp = *this;
|
||||
_M_bump_down();
|
||||
return __tmp;
|
||||
}
|
||||
iterator& operator+=(difference_type __i) {
|
||||
_M_incr(__i);
|
||||
return *this;
|
||||
}
|
||||
iterator& operator-=(difference_type __i) {
|
||||
*this += -__i;
|
||||
return *this;
|
||||
}
|
||||
iterator operator+(difference_type __i) const {
|
||||
iterator __tmp = *this;
|
||||
return __tmp += __i;
|
||||
}
|
||||
iterator operator-(difference_type __i) const {
|
||||
iterator __tmp = *this;
|
||||
return __tmp -= __i;
|
||||
}
|
||||
|
||||
reference operator[](difference_type __i) { return *(*this + __i); }
|
||||
};
|
||||
|
||||
inline _Bit_iterator
|
||||
operator+(ptrdiff_t __n, const _Bit_iterator& __x) { return __x + __n; }
|
||||
|
||||
|
||||
struct _Bit_const_iterator : public _Bit_iterator_base
|
||||
{
|
||||
typedef bool reference;
|
||||
typedef bool const_reference;
|
||||
typedef const bool* pointer;
|
||||
typedef _Bit_const_iterator const_iterator;
|
||||
|
||||
_Bit_const_iterator() : _Bit_iterator_base(0, 0) {}
|
||||
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
|
||||
: _Bit_iterator_base(__x, __y) {}
|
||||
_Bit_const_iterator(const _Bit_iterator& __x)
|
||||
: _Bit_iterator_base(__x._M_p, __x._M_offset) {}
|
||||
|
||||
const_reference operator*() const {
|
||||
return _Bit_reference(_M_p, 1UL << _M_offset);
|
||||
}
|
||||
const_iterator& operator++() {
|
||||
_M_bump_up();
|
||||
return *this;
|
||||
}
|
||||
const_iterator operator++(int) {
|
||||
const_iterator __tmp = *this;
|
||||
_M_bump_up();
|
||||
return __tmp;
|
||||
}
|
||||
const_iterator& operator--() {
|
||||
_M_bump_down();
|
||||
return *this;
|
||||
}
|
||||
const_iterator operator--(int) {
|
||||
const_iterator __tmp = *this;
|
||||
_M_bump_down();
|
||||
return __tmp;
|
||||
}
|
||||
const_iterator& operator+=(difference_type __i) {
|
||||
_M_incr(__i);
|
||||
return *this;
|
||||
}
|
||||
const_iterator& operator-=(difference_type __i) {
|
||||
*this += -__i;
|
||||
return *this;
|
||||
}
|
||||
const_iterator operator+(difference_type __i) const {
|
||||
const_iterator __tmp = *this;
|
||||
return __tmp += __i;
|
||||
}
|
||||
const_iterator operator-(difference_type __i) const {
|
||||
const_iterator __tmp = *this;
|
||||
return __tmp -= __i;
|
||||
}
|
||||
const_reference operator[](difference_type __i) {
|
||||
return *(*this + __i);
|
||||
}
|
||||
};
|
||||
|
||||
inline _Bit_const_iterator
|
||||
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) { return __x + __n; }
|
||||
|
||||
|
||||
// Bit-vector base class, which encapsulates the difference between
|
||||
// old SGI-style allocators and standard-conforming allocators.
|
||||
|
||||
// Base class for ordinary allocators.
|
||||
template <class _Allocator, bool __is_static>
|
||||
class _Bvector_alloc_base {
|
||||
public:
|
||||
typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
|
||||
allocator_type;
|
||||
allocator_type get_allocator() const { return _M_data_allocator; }
|
||||
|
||||
_Bvector_alloc_base(const allocator_type& __a)
|
||||
: _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}
|
||||
|
||||
protected:
|
||||
_Bit_type * _M_bit_alloc(size_t __n)
|
||||
{ return _M_data_allocator.allocate((__n + _M_word_bit - 1)/_M_word_bit); }
|
||||
void _M_deallocate() {
|
||||
if (_M_start._M_p)
|
||||
_M_data_allocator.deallocate(_M_start._M_p,
|
||||
_M_end_of_storage - _M_start._M_p);
|
||||
}
|
||||
|
||||
typename _Alloc_traits<_Bit_type, _Allocator>::allocator_type
|
||||
_M_data_allocator;
|
||||
_Bit_iterator _M_start;
|
||||
_Bit_iterator _M_finish;
|
||||
_Bit_type * _M_end_of_storage;
|
||||
};
|
||||
|
||||
// Specialization for instanceless allocators.
|
||||
template <class _Allocator>
|
||||
class _Bvector_alloc_base<_Allocator, true> {
|
||||
public:
|
||||
typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
|
||||
allocator_type;
|
||||
allocator_type get_allocator() const { return allocator_type(); }
|
||||
|
||||
_Bvector_alloc_base(const allocator_type&)
|
||||
: _M_start(), _M_finish(), _M_end_of_storage(0) {}
|
||||
|
||||
protected:
|
||||
typedef typename _Alloc_traits<_Bit_type, _Allocator>::_Alloc_type
|
||||
_Alloc_type;
|
||||
|
||||
_Bit_type * _M_bit_alloc(size_t __n)
|
||||
{ return _Alloc_type::allocate((__n + _M_word_bit - 1)/_M_word_bit); }
|
||||
void _M_deallocate() {
|
||||
if (_M_start._M_p)
|
||||
_Alloc_type::deallocate(_M_start._M_p,
|
||||
_M_end_of_storage - _M_start._M_p);
|
||||
}
|
||||
|
||||
_Bit_iterator _M_start;
|
||||
_Bit_iterator _M_finish;
|
||||
_Bit_type * _M_end_of_storage;
|
||||
};
|
||||
|
||||
template <class _Alloc>
|
||||
class _Bvector_base
|
||||
: public _Bvector_alloc_base<_Alloc,
|
||||
_Alloc_traits<bool, _Alloc>::_S_instanceless>
|
||||
{
|
||||
typedef _Bvector_alloc_base<_Alloc,
|
||||
_Alloc_traits<bool, _Alloc>::_S_instanceless>
|
||||
_Base;
|
||||
public:
|
||||
typedef typename _Base::allocator_type allocator_type;
|
||||
|
||||
_Bvector_base(const allocator_type& __a) : _Base(__a) {}
|
||||
~_Bvector_base() { _Base::_M_deallocate(); }
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
// Declare a partial specialization of vector<T, Alloc>.
|
||||
#include <bits/stl_vector.h>
|
||||
namespace std
|
||||
{
|
||||
|
||||
template <typename _Alloc>
|
||||
class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
|
||||
{
|
||||
public:
|
||||
typedef bool value_type;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef _Bit_reference reference;
|
||||
typedef bool const_reference;
|
||||
typedef _Bit_reference* pointer;
|
||||
typedef const bool* const_pointer;
|
||||
|
||||
typedef _Bit_iterator iterator;
|
||||
typedef _Bit_const_iterator const_iterator;
|
||||
|
||||
typedef reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
typedef reverse_iterator<iterator> reverse_iterator;
|
||||
|
||||
typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
|
||||
allocator_type get_allocator() const {
|
||||
return _Bvector_base<_Alloc>::get_allocator();
|
||||
}
|
||||
|
||||
protected:
|
||||
using _Bvector_base<_Alloc>::_M_bit_alloc;
|
||||
using _Bvector_base<_Alloc>::_M_deallocate;
|
||||
using _Bvector_base<_Alloc>::_M_start;
|
||||
using _Bvector_base<_Alloc>::_M_finish;
|
||||
using _Bvector_base<_Alloc>::_M_end_of_storage;
|
||||
|
||||
protected:
|
||||
void _M_initialize(size_type __n) {
|
||||
_Bit_type * __q = _M_bit_alloc(__n);
|
||||
_M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
|
||||
_M_start = iterator(__q, 0);
|
||||
_M_finish = _M_start + difference_type(__n);
|
||||
}
|
||||
void _M_insert_aux(iterator __position, bool __x) {
|
||||
if (_M_finish._M_p != _M_end_of_storage) {
|
||||
copy_backward(__position, _M_finish, _M_finish + 1);
|
||||
*__position = __x;
|
||||
++_M_finish;
|
||||
}
|
||||
else {
|
||||
size_type __len = size()
|
||||
? 2 * size() : static_cast<size_type>(_M_word_bit);
|
||||
_Bit_type * __q = _M_bit_alloc(__len);
|
||||
iterator __i = copy(begin(), __position, iterator(__q, 0));
|
||||
*__i++ = __x;
|
||||
_M_finish = copy(__position, end(), __i);
|
||||
_M_deallocate();
|
||||
_M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
|
||||
_M_start = iterator(__q, 0);
|
||||
}
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void _M_initialize_range(_InputIterator __first, _InputIterator __last,
|
||||
input_iterator_tag) {
|
||||
_M_start = iterator();
|
||||
_M_finish = iterator();
|
||||
_M_end_of_storage = 0;
|
||||
for ( ; __first != __last; ++__first)
|
||||
push_back(*__first);
|
||||
}
|
||||
|
||||
template <class _ForwardIterator>
|
||||
void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
|
||||
forward_iterator_tag) {
|
||||
size_type __n = distance(__first, __last);
|
||||
_M_initialize(__n);
|
||||
copy(__first, __last, _M_start);
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void _M_insert_range(iterator __pos,
|
||||
_InputIterator __first, _InputIterator __last,
|
||||
input_iterator_tag) {
|
||||
for ( ; __first != __last; ++__first) {
|
||||
__pos = insert(__pos, *__first);
|
||||
++__pos;
|
||||
}
|
||||
}
|
||||
|
||||
template <class _ForwardIterator>
|
||||
void _M_insert_range(iterator __position,
|
||||
_ForwardIterator __first, _ForwardIterator __last,
|
||||
forward_iterator_tag) {
|
||||
if (__first != __last) {
|
||||
size_type __n = distance(__first, __last);
|
||||
if (capacity() - size() >= __n) {
|
||||
copy_backward(__position, end(), _M_finish + difference_type(__n));
|
||||
copy(__first, __last, __position);
|
||||
_M_finish += difference_type(__n);
|
||||
}
|
||||
else {
|
||||
size_type __len = size() + max(size(), __n);
|
||||
_Bit_type * __q = _M_bit_alloc(__len);
|
||||
iterator __i = copy(begin(), __position, iterator(__q, 0));
|
||||
__i = copy(__first, __last, __i);
|
||||
_M_finish = copy(__position, end(), __i);
|
||||
_M_deallocate();
|
||||
_M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
|
||||
_M_start = iterator(__q, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
iterator begin() { return _M_start; }
|
||||
const_iterator begin() const { return _M_start; }
|
||||
iterator end() { return _M_finish; }
|
||||
const_iterator end() const { return _M_finish; }
|
||||
|
||||
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 size_type(end() - begin()); }
|
||||
size_type max_size() const { return size_type(-1); }
|
||||
size_type capacity() const {
|
||||
return size_type(const_iterator(_M_end_of_storage, 0) - begin());
|
||||
}
|
||||
bool empty() const { return begin() == end(); }
|
||||
|
||||
reference operator[](size_type __n)
|
||||
{ return *(begin() + difference_type(__n)); }
|
||||
const_reference operator[](size_type __n) const
|
||||
{ return *(begin() + difference_type(__n)); }
|
||||
|
||||
void _M_range_check(size_type __n) const {
|
||||
if (__n >= this->size())
|
||||
__throw_out_of_range("vector<bool>");
|
||||
}
|
||||
|
||||
reference at(size_type __n)
|
||||
{ _M_range_check(__n); return (*this)[__n]; }
|
||||
const_reference at(size_type __n) const
|
||||
{ _M_range_check(__n); return (*this)[__n]; }
|
||||
|
||||
explicit vector(const allocator_type& __a = allocator_type())
|
||||
: _Bvector_base<_Alloc>(__a) {}
|
||||
|
||||
vector(size_type __n, bool __value,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _Bvector_base<_Alloc>(__a)
|
||||
{
|
||||
_M_initialize(__n);
|
||||
fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
|
||||
}
|
||||
|
||||
explicit vector(size_type __n)
|
||||
: _Bvector_base<_Alloc>(allocator_type())
|
||||
{
|
||||
_M_initialize(__n);
|
||||
fill(_M_start._M_p, _M_end_of_storage, 0);
|
||||
}
|
||||
|
||||
vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
|
||||
_M_initialize(__x.size());
|
||||
copy(__x.begin(), __x.end(), _M_start);
|
||||
}
|
||||
|
||||
// Check whether it's an integral type. If so, it's not an iterator.
|
||||
|
||||
template <class _Integer>
|
||||
void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
|
||||
_M_initialize(__n);
|
||||
fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
|
||||
__false_type) {
|
||||
_M_initialize_range(__first, __last, __iterator_category(__first));
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
vector(_InputIterator __first, _InputIterator __last,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _Bvector_base<_Alloc>(__a)
|
||||
{
|
||||
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
|
||||
_M_initialize_dispatch(__first, __last, _Integral());
|
||||
}
|
||||
|
||||
~vector() { }
|
||||
|
||||
vector& operator=(const vector& __x) {
|
||||
if (&__x == this) return *this;
|
||||
if (__x.size() > capacity()) {
|
||||
_M_deallocate();
|
||||
_M_initialize(__x.size());
|
||||
}
|
||||
copy(__x.begin(), __x.end(), begin());
|
||||
_M_finish = begin() + difference_type(__x.size());
|
||||
return *this;
|
||||
}
|
||||
|
||||
// assign(), a generalized assignment member function. Two
|
||||
// versions: one that takes a count, and one that takes a range.
|
||||
// The range version is a member template, so we dispatch on whether
|
||||
// or not the type is an integer.
|
||||
|
||||
void _M_fill_assign(size_t __n, bool __x) {
|
||||
if (__n > size()) {
|
||||
fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
|
||||
insert(end(), __n - size(), __x);
|
||||
}
|
||||
else {
|
||||
erase(begin() + __n, end());
|
||||
fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
|
||||
}
|
||||
}
|
||||
|
||||
void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
|
||||
|
||||
template <class _InputIterator>
|
||||
void assign(_InputIterator __first, _InputIterator __last) {
|
||||
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
|
||||
_M_assign_dispatch(__first, __last, _Integral());
|
||||
}
|
||||
|
||||
template <class _Integer>
|
||||
void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
||||
{ _M_fill_assign((size_t) __n, (bool) __val); }
|
||||
|
||||
template <class _InputIter>
|
||||
void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
|
||||
{ _M_assign_aux(__first, __last, __iterator_category(__first)); }
|
||||
|
||||
template <class _InputIterator>
|
||||
void _M_assign_aux(_InputIterator __first, _InputIterator __last,
|
||||
input_iterator_tag) {
|
||||
iterator __cur = begin();
|
||||
for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
|
||||
*__cur = *__first;
|
||||
if (__first == __last)
|
||||
erase(__cur, end());
|
||||
else
|
||||
insert(end(), __first, __last);
|
||||
}
|
||||
|
||||
template <class _ForwardIterator>
|
||||
void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
|
||||
forward_iterator_tag) {
|
||||
size_type __len = distance(__first, __last);
|
||||
if (__len < size())
|
||||
erase(copy(__first, __last, begin()), end());
|
||||
else {
|
||||
_ForwardIterator __mid = __first;
|
||||
advance(__mid, size());
|
||||
copy(__first, __mid, begin());
|
||||
insert(end(), __mid, __last);
|
||||
}
|
||||
}
|
||||
|
||||
void reserve(size_type __n) {
|
||||
if (__n > this->max_size())
|
||||
__throw_length_error("vector::reserve");
|
||||
if (this->capacity() < __n) {
|
||||
_Bit_type * __q = _M_bit_alloc(__n);
|
||||
_M_finish = copy(begin(), end(), iterator(__q, 0));
|
||||
_M_deallocate();
|
||||
_M_start = iterator(__q, 0);
|
||||
_M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
|
||||
}
|
||||
}
|
||||
|
||||
reference front() { return *begin(); }
|
||||
const_reference front() const { return *begin(); }
|
||||
reference back() { return *(end() - 1); }
|
||||
const_reference back() const { return *(end() - 1); }
|
||||
void push_back(bool __x) {
|
||||
if (_M_finish._M_p != _M_end_of_storage)
|
||||
*_M_finish++ = __x;
|
||||
else
|
||||
_M_insert_aux(end(), __x);
|
||||
}
|
||||
void swap(vector<bool, _Alloc>& __x) {
|
||||
std::swap(_M_start, __x._M_start);
|
||||
std::swap(_M_finish, __x._M_finish);
|
||||
std::swap(_M_end_of_storage, __x._M_end_of_storage);
|
||||
}
|
||||
iterator insert(iterator __position, bool __x = bool()) {
|
||||
difference_type __n = __position - begin();
|
||||
if (_M_finish._M_p != _M_end_of_storage && __position == end())
|
||||
*_M_finish++ = __x;
|
||||
else
|
||||
_M_insert_aux(__position, __x);
|
||||
return begin() + __n;
|
||||
}
|
||||
|
||||
// Check whether it's an integral type. If so, it's not an iterator.
|
||||
|
||||
template <class _Integer>
|
||||
void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
|
||||
__true_type) {
|
||||
_M_fill_insert(__pos, __n, __x);
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void _M_insert_dispatch(iterator __pos,
|
||||
_InputIterator __first, _InputIterator __last,
|
||||
__false_type) {
|
||||
_M_insert_range(__pos, __first, __last, __iterator_category(__first));
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void insert(iterator __position,
|
||||
_InputIterator __first, _InputIterator __last) {
|
||||
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
|
||||
_M_insert_dispatch(__position, __first, __last, _Integral());
|
||||
}
|
||||
|
||||
void _M_fill_insert(iterator __position, size_type __n, bool __x) {
|
||||
if (__n == 0) return;
|
||||
if (capacity() - size() >= __n) {
|
||||
copy_backward(__position, end(), _M_finish + difference_type(__n));
|
||||
fill(__position, __position + difference_type(__n), __x);
|
||||
_M_finish += difference_type(__n);
|
||||
}
|
||||
else {
|
||||
size_type __len = size() + max(size(), __n);
|
||||
_Bit_type * __q = _M_bit_alloc(__len);
|
||||
iterator __i = copy(begin(), __position, iterator(__q, 0));
|
||||
fill_n(__i, __n, __x);
|
||||
_M_finish = copy(__position, end(), __i + difference_type(__n));
|
||||
_M_deallocate();
|
||||
_M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
|
||||
_M_start = iterator(__q, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void insert(iterator __position, size_type __n, bool __x) {
|
||||
_M_fill_insert(__position, __n, __x);
|
||||
}
|
||||
|
||||
void pop_back() { --_M_finish; }
|
||||
iterator erase(iterator __position) {
|
||||
if (__position + 1 != end())
|
||||
copy(__position + 1, end(), __position);
|
||||
--_M_finish;
|
||||
return __position;
|
||||
}
|
||||
iterator erase(iterator __first, iterator __last) {
|
||||
_M_finish = copy(__last, end(), __first);
|
||||
return __first;
|
||||
}
|
||||
void resize(size_type __new_size, bool __x = bool()) {
|
||||
if (__new_size < size())
|
||||
erase(begin() + difference_type(__new_size), end());
|
||||
else
|
||||
insert(end(), __new_size - size(), __x);
|
||||
}
|
||||
void flip() {
|
||||
for (_Bit_type * __p = _M_start._M_p; __p != _M_end_of_storage; ++__p)
|
||||
*__p = ~*__p;
|
||||
}
|
||||
|
||||
void clear() { erase(begin(), end()); }
|
||||
};
|
||||
|
||||
// This typedef is non-standard. It is provided for backward compatibility.
|
||||
typedef vector<bool, __alloc> bit_vector;
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_BVECTOR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
148
TBE/MinGW/include/c++/3.2.3/bits/stl_construct.h
Normal file
148
TBE/MinGW/include/c++/3.2.3/bits/stl_construct.h
Normal file
@@ -0,0 +1,148 @@
|
||||
// nonstandard construct and destroy functions -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_construct.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_CONSTRUCT_H
|
||||
#define _CPP_BITS_STL_CONSTRUCT_H 1
|
||||
|
||||
#include <bits/type_traits.h>
|
||||
#include <new>
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* @if maint
|
||||
* Constructs an object in existing memory by invoking an allocated
|
||||
* object's constructor with an initializer.
|
||||
* @endif
|
||||
*/
|
||||
template <class _T1, class _T2>
|
||||
inline void
|
||||
_Construct(_T1* __p, const _T2& __value)
|
||||
{ new (static_cast<void*>(__p)) _T1(__value); }
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Constructs an object in existing memory by invoking an allocated
|
||||
* object's default constructor (no initializers).
|
||||
* @endif
|
||||
*/
|
||||
template <class _T1>
|
||||
inline void
|
||||
_Construct(_T1* __p)
|
||||
{ new (static_cast<void*>(__p)) _T1(); }
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Destroy a range of objects with nontrivial destructors.
|
||||
*
|
||||
* This is a helper function used only by _Destroy().
|
||||
* @endif
|
||||
*/
|
||||
template <class _ForwardIterator>
|
||||
inline void
|
||||
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
|
||||
{ for ( ; __first != __last; ++__first) _Destroy(&*__first); }
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Destroy a range of objects with trivial destructors. Since the destructors
|
||||
* are trivial, there's nothing to do and hopefully this function will be
|
||||
* entirely optimized away.
|
||||
*
|
||||
* This is a helper function used only by _Destroy().
|
||||
* @endif
|
||||
*/
|
||||
template <class _ForwardIterator>
|
||||
inline void
|
||||
__destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
|
||||
{ }
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Destroy the object pointed to by a pointer type.
|
||||
* @endif
|
||||
*/
|
||||
template <class _Tp>
|
||||
inline void
|
||||
_Destroy(_Tp* __pointer)
|
||||
{ __pointer->~_Tp(); }
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Destroy a range of objects. If the value_type of the object has
|
||||
* a trivial destructor, the compiler should optimize all of this
|
||||
* away, otherwise the objects' destructors must be invoked.
|
||||
* @endif
|
||||
*/
|
||||
template <class _ForwardIterator>
|
||||
inline void
|
||||
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
|
||||
{
|
||||
typedef typename iterator_traits<_ForwardIterator>::value_type
|
||||
_Value_type;
|
||||
typedef typename __type_traits<_Value_type>::has_trivial_destructor
|
||||
_Has_trivial_destructor;
|
||||
|
||||
__destroy_aux(__first, __last, _Has_trivial_destructor());
|
||||
}
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_CONSTRUCT_H */
|
||||
|
||||
1682
TBE/MinGW/include/c++/3.2.3/bits/stl_deque.h
Normal file
1682
TBE/MinGW/include/c++/3.2.3/bits/stl_deque.h
Normal file
File diff suppressed because it is too large
Load Diff
736
TBE/MinGW/include/c++/3.2.3/bits/stl_function.h
Normal file
736
TBE/MinGW/include/c++/3.2.3/bits/stl_function.h
Normal file
@@ -0,0 +1,736 @@
|
||||
// Functor implementations -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_function.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_FUNCTION_H
|
||||
#define __GLIBCPP_INTERNAL_FUNCTION_H
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 20.3.1 base classes
|
||||
/** @defgroup s20_3_1_base Functor Base Classes
|
||||
* Function objects, or @e functors, are objects with an @c operator()
|
||||
* defined and accessible. They can be passed as arguments to algorithm
|
||||
* templates and used in place of a function pointer. Not only is the
|
||||
* resulting expressiveness of the library increased, but the generated
|
||||
* code can be more efficient than what you might write by hand. When we
|
||||
* refer to "functors," then, generally we include function pointers in
|
||||
* the description as well.
|
||||
*
|
||||
* Often, functors are only created as temporaries passed to algorithm
|
||||
* calls, rather than being created as named variables.
|
||||
*
|
||||
* Two examples taken from the standard itself follow. To perform a
|
||||
* by-element addition of two vectors @c a and @c b containing @c double,
|
||||
* and put the result in @c a, use
|
||||
* \code
|
||||
* transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
|
||||
* \endcode
|
||||
* To negate every element in @c a, use
|
||||
* \code
|
||||
* transform(a.begin(), a.end(), a.begin(), negate<double>());
|
||||
* \endcode
|
||||
* The addition and negation functions will be inlined directly.
|
||||
*
|
||||
* The standard functiors are derived from structs named @c unary_function
|
||||
* and @c binary_function. These two classes contain nothing but typedefs,
|
||||
* to aid in generic (template) programming. If you write your own
|
||||
* functors, you might consider doing the same.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/**
|
||||
* This is one of the @link s20_3_1_base functor base classes@endlink.
|
||||
*/
|
||||
template <class _Arg, class _Result>
|
||||
struct unary_function {
|
||||
typedef _Arg argument_type; ///< @c argument_type is the type of the argument (no surprises here)
|
||||
typedef _Result result_type; ///< @c result_type is the return type
|
||||
};
|
||||
|
||||
/**
|
||||
* This is one of the @link s20_3_1_base functor base classes@endlink.
|
||||
*/
|
||||
template <class _Arg1, class _Arg2, class _Result>
|
||||
struct binary_function {
|
||||
typedef _Arg1 first_argument_type; ///< the type of the first argument (no surprises here)
|
||||
typedef _Arg2 second_argument_type; ///< the type of the second argument
|
||||
typedef _Result result_type; ///< type of the return type
|
||||
};
|
||||
/** @} */
|
||||
|
||||
// 20.3.2 arithmetic
|
||||
/** @defgroup s20_3_2_arithmetic Arithmetic Classes
|
||||
* Because basic math often needs to be done during an algorithm, the library
|
||||
* provides functors for those operations. See the documentation for
|
||||
* @link s20_3_1_base the base classes@endlink for examples of their use.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct plus : public binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct minus : public binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct divides : public binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct modulus : public binary_function<_Tp,_Tp,_Tp>
|
||||
{
|
||||
_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_2_arithmetic math functors@endlink.
|
||||
template <class _Tp>
|
||||
struct negate : public unary_function<_Tp,_Tp>
|
||||
{
|
||||
_Tp operator()(const _Tp& __x) const { return -__x; }
|
||||
};
|
||||
/** @} */
|
||||
|
||||
// 20.3.3 comparisons
|
||||
/** @defgroup s20_3_3_comparisons Comparison Classes
|
||||
* The library provides six wrapper functors for all the basic comparisons
|
||||
* in C++, like @c <.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct equal_to : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct not_equal_to : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct greater : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct less : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct greater_equal : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_3_comparisons comparison functors@endlink.
|
||||
template <class _Tp>
|
||||
struct less_equal : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
|
||||
};
|
||||
/** @} */
|
||||
|
||||
// 20.3.4 logical operations
|
||||
/** @defgroup s20_3_4_logical Boolean Operations Classes
|
||||
* Here are wrapper functors for Boolean operations: @c &&, @c ||, and @c !.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
|
||||
template <class _Tp>
|
||||
struct logical_and : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
|
||||
template <class _Tp>
|
||||
struct logical_or : public binary_function<_Tp,_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_4_logical Boolean operations functors@endlink.
|
||||
template <class _Tp>
|
||||
struct logical_not : public unary_function<_Tp,bool>
|
||||
{
|
||||
bool operator()(const _Tp& __x) const { return !__x; }
|
||||
};
|
||||
/** @} */
|
||||
|
||||
// 20.3.5 negators
|
||||
/** @defgroup s20_3_5_negators Negators
|
||||
* The functions @c not1 and @c not2 each take a predicate functor
|
||||
* and return an instance of @c unary_negate or
|
||||
* @c binary_negate, respectively. These classes are functors whose
|
||||
* @c operator() performs the stored predicate function and then returns
|
||||
* the negation of the result.
|
||||
*
|
||||
* For example, given a vector of integers and a trivial predicate,
|
||||
* \code
|
||||
* struct IntGreaterThanThree
|
||||
* : public std::unary_function<int, bool>
|
||||
* {
|
||||
* bool operator() (int x) { return x > 3; }
|
||||
* };
|
||||
*
|
||||
* std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
|
||||
* \endcode
|
||||
* The call to @c find_if will locate the first index (i) of @c v for which
|
||||
* "!(v[i] > 3)" is true.
|
||||
*
|
||||
* The not1/unary_negate combination works on predicates taking a single
|
||||
* argument. The not2/binary_negate combination works on predicates which
|
||||
* take two arguments.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_5_negators negation functors@endlink.
|
||||
template <class _Predicate>
|
||||
class unary_negate
|
||||
: public unary_function<typename _Predicate::argument_type, bool> {
|
||||
protected:
|
||||
_Predicate _M_pred;
|
||||
public:
|
||||
explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
|
||||
bool operator()(const typename _Predicate::argument_type& __x) const {
|
||||
return !_M_pred(__x);
|
||||
}
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_5_negators negation functors@endlink.
|
||||
template <class _Predicate>
|
||||
inline unary_negate<_Predicate>
|
||||
not1(const _Predicate& __pred)
|
||||
{
|
||||
return unary_negate<_Predicate>(__pred);
|
||||
}
|
||||
|
||||
/// One of the @link s20_3_5_negators negation functors@endlink.
|
||||
template <class _Predicate>
|
||||
class binary_negate
|
||||
: public binary_function<typename _Predicate::first_argument_type,
|
||||
typename _Predicate::second_argument_type,
|
||||
bool> {
|
||||
protected:
|
||||
_Predicate _M_pred;
|
||||
public:
|
||||
explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
|
||||
bool operator()(const typename _Predicate::first_argument_type& __x,
|
||||
const typename _Predicate::second_argument_type& __y) const
|
||||
{
|
||||
return !_M_pred(__x, __y);
|
||||
}
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_5_negators negation functors@endlink.
|
||||
template <class _Predicate>
|
||||
inline binary_negate<_Predicate>
|
||||
not2(const _Predicate& __pred)
|
||||
{
|
||||
return binary_negate<_Predicate>(__pred);
|
||||
}
|
||||
/** @} */
|
||||
|
||||
// 20.3.6 binders
|
||||
/** @defgroup s20_3_6_binder Binder Classes
|
||||
* Binders turn functions/functors with two arguments into functors with
|
||||
* a single argument, storing an argument to be applied later. For
|
||||
* example, an variable @c B of type @c binder1st is constructed from a functor
|
||||
* @c f and an argument @c x. Later, B's @c operator() is called with a
|
||||
* single argument @c y. The return value is the value of @c f(x,y).
|
||||
* @c B can be "called" with various arguments (y1, y2, ...) and will in
|
||||
* turn call @c f(x,y1), @c f(x,y2), ...
|
||||
*
|
||||
* The function @c bind1st is provided to save some typing. It takes the
|
||||
* function and an argument as parameters, and returns an instance of
|
||||
* @c binder1st.
|
||||
*
|
||||
* The type @c binder2nd and its creator function @c bind2nd do the same
|
||||
* thing, but the stored argument is passed as the second parameter instead
|
||||
* of the first, e.g., @c bind2nd(std::minus<float>,1.3) will create a
|
||||
* functor whose @c operator() accepts a floating-point number, subtracts
|
||||
* 1.3 from it, and returns the result. (If @c bind1st had been used,
|
||||
* the functor would perform "1.3 - x" instead.
|
||||
*
|
||||
* Creator-wrapper functions like @c bind1st are intended to be used in
|
||||
* calling algorithms. Their return values will be temporary objects.
|
||||
* (The goal is to not require you to type names like
|
||||
* @c std::binder1st<std::plus<int>> for declaring a variable to hold the
|
||||
* return value from @c bind1st(std::plus<int>,5).
|
||||
*
|
||||
* These become more useful when combined with the composition functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_6_binder binder functors@endlink.
|
||||
template <class _Operation>
|
||||
class binder1st
|
||||
: public unary_function<typename _Operation::second_argument_type,
|
||||
typename _Operation::result_type> {
|
||||
protected:
|
||||
_Operation op;
|
||||
typename _Operation::first_argument_type value;
|
||||
public:
|
||||
binder1st(const _Operation& __x,
|
||||
const typename _Operation::first_argument_type& __y)
|
||||
: op(__x), value(__y) {}
|
||||
typename _Operation::result_type
|
||||
operator()(const typename _Operation::second_argument_type& __x) const {
|
||||
return op(value, __x);
|
||||
}
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//109. Missing binders for non-const sequence elements
|
||||
typename _Operation::result_type
|
||||
operator()(typename _Operation::second_argument_type& __x) const {
|
||||
return op(value, __x);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_6_binder binder functors@endlink.
|
||||
template <class _Operation, class _Tp>
|
||||
inline binder1st<_Operation>
|
||||
bind1st(const _Operation& __fn, const _Tp& __x)
|
||||
{
|
||||
typedef typename _Operation::first_argument_type _Arg1_type;
|
||||
return binder1st<_Operation>(__fn, _Arg1_type(__x));
|
||||
}
|
||||
|
||||
/// One of the @link s20_3_6_binder binder functors@endlink.
|
||||
template <class _Operation>
|
||||
class binder2nd
|
||||
: public unary_function<typename _Operation::first_argument_type,
|
||||
typename _Operation::result_type> {
|
||||
protected:
|
||||
_Operation op;
|
||||
typename _Operation::second_argument_type value;
|
||||
public:
|
||||
binder2nd(const _Operation& __x,
|
||||
const typename _Operation::second_argument_type& __y)
|
||||
: op(__x), value(__y) {}
|
||||
typename _Operation::result_type
|
||||
operator()(const typename _Operation::first_argument_type& __x) const {
|
||||
return op(__x, value);
|
||||
}
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//109. Missing binders for non-const sequence elements
|
||||
typename _Operation::result_type
|
||||
operator()(typename _Operation::first_argument_type& __x) const {
|
||||
return op(__x, value);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_6_binder binder functors@endlink.
|
||||
template <class _Operation, class _Tp>
|
||||
inline binder2nd<_Operation>
|
||||
bind2nd(const _Operation& __fn, const _Tp& __x)
|
||||
{
|
||||
typedef typename _Operation::second_argument_type _Arg2_type;
|
||||
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
|
||||
}
|
||||
/** @} */
|
||||
|
||||
// 20.3.7 adaptors pointers functions
|
||||
/** @defgroup s20_3_7_adaptors Adaptors for pointers to functions
|
||||
* The advantage of function objects over pointers to functions is that
|
||||
* the objects in the standard library declare nested typedefs describing
|
||||
* their argument and result types with uniform names (e.g., @c result_type
|
||||
* from the base classes @c unary_function and @c binary_function).
|
||||
* Sometimes those typedefs are required, not just optional.
|
||||
*
|
||||
* Adaptors are provided to turn pointers to unary (single-argument) and
|
||||
* binary (double-argument) functions into function objects. The long-winded
|
||||
* functor @c pointer_to_unary_function is constructed with a function
|
||||
* pointer @c f, and its @c operator() called with argument @c x returns
|
||||
* @c f(x). The functor @c pointer_to_binary_function does the same thing,
|
||||
* but with a double-argument @c f and @c operator().
|
||||
*
|
||||
* The function @c ptr_fun takes a pointer-to-function @c f and constructs
|
||||
* an instance of the appropriate functor.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
|
||||
template <class _Arg, class _Result>
|
||||
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
|
||||
protected:
|
||||
_Result (*_M_ptr)(_Arg);
|
||||
public:
|
||||
pointer_to_unary_function() {}
|
||||
explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
|
||||
_Result operator()(_Arg __x) const { return _M_ptr(__x); }
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
|
||||
template <class _Arg, class _Result>
|
||||
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
|
||||
{
|
||||
return pointer_to_unary_function<_Arg, _Result>(__x);
|
||||
}
|
||||
|
||||
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
|
||||
template <class _Arg1, class _Arg2, class _Result>
|
||||
class pointer_to_binary_function :
|
||||
public binary_function<_Arg1,_Arg2,_Result> {
|
||||
protected:
|
||||
_Result (*_M_ptr)(_Arg1, _Arg2);
|
||||
public:
|
||||
pointer_to_binary_function() {}
|
||||
explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
|
||||
: _M_ptr(__x) {}
|
||||
_Result operator()(_Arg1 __x, _Arg2 __y) const {
|
||||
return _M_ptr(__x, __y);
|
||||
}
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_7_adaptors adaptors for function pointers@endlink.
|
||||
template <class _Arg1, class _Arg2, class _Result>
|
||||
inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
|
||||
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
|
||||
return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
|
||||
}
|
||||
/** @} */
|
||||
|
||||
template <class _Tp>
|
||||
struct _Identity : public unary_function<_Tp,_Tp> {
|
||||
_Tp& operator()(_Tp& __x) const { return __x; }
|
||||
const _Tp& operator()(const _Tp& __x) const { return __x; }
|
||||
};
|
||||
|
||||
template <class _Pair>
|
||||
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
|
||||
typename _Pair::first_type& operator()(_Pair& __x) const {
|
||||
return __x.first;
|
||||
}
|
||||
const typename _Pair::first_type& operator()(const _Pair& __x) const {
|
||||
return __x.first;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Pair>
|
||||
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
|
||||
{
|
||||
typename _Pair::second_type& operator()(_Pair& __x) const {
|
||||
return __x.second;
|
||||
}
|
||||
const typename _Pair::second_type& operator()(const _Pair& __x) const {
|
||||
return __x.second;
|
||||
}
|
||||
};
|
||||
|
||||
// 20.3.8 adaptors pointers members
|
||||
/** @defgroup s20_3_8_memadaptors Adaptors for pointers to members
|
||||
* There are a total of 16 = 2^4 function objects in this family.
|
||||
* (1) Member functions taking no arguments vs member functions taking
|
||||
* one argument.
|
||||
* (2) Call through pointer vs call through reference.
|
||||
* (3) Member function with void return type vs member function with
|
||||
* non-void return type.
|
||||
* (4) Const vs non-const member function.
|
||||
*
|
||||
* Note that choice (3) is nothing more than a workaround: according
|
||||
* to the draft, compilers should handle void and non-void the same way.
|
||||
* This feature is not yet widely implemented, though. You can only use
|
||||
* member functions returning void if your compiler supports partial
|
||||
* specialization.
|
||||
*
|
||||
* All of this complexity is in the function objects themselves. You can
|
||||
* ignore it by using the helper function mem_fun and mem_fun_ref,
|
||||
* which create whichever type of adaptor is appropriate.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp>
|
||||
class mem_fun_t : public unary_function<_Tp*,_Ret> {
|
||||
public:
|
||||
explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
|
||||
_Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)();
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp>
|
||||
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
|
||||
public:
|
||||
explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
|
||||
_Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)() const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp>
|
||||
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
|
||||
public:
|
||||
explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
|
||||
_Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)();
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp>
|
||||
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
|
||||
public:
|
||||
explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
|
||||
_Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)() const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
|
||||
public:
|
||||
explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
|
||||
_Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)(_Arg);
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
|
||||
public:
|
||||
explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
|
||||
_Ret operator()(const _Tp* __p, _Arg __x) const
|
||||
{ return (__p->*_M_f)(__x); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)(_Arg) const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
|
||||
public:
|
||||
explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
|
||||
_Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)(_Arg);
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
|
||||
public:
|
||||
explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
|
||||
_Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
|
||||
private:
|
||||
_Ret (_Tp::*_M_f)(_Arg) const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp>
|
||||
class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
|
||||
public:
|
||||
explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
|
||||
void operator()(_Tp* __p) const { (__p->*_M_f)(); }
|
||||
private:
|
||||
void (_Tp::*_M_f)();
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp>
|
||||
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
|
||||
public:
|
||||
explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
|
||||
void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
|
||||
private:
|
||||
void (_Tp::*_M_f)() const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp>
|
||||
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
|
||||
public:
|
||||
explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
|
||||
void operator()(_Tp& __r) const { (__r.*_M_f)(); }
|
||||
private:
|
||||
void (_Tp::*_M_f)();
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp>
|
||||
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
|
||||
public:
|
||||
explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
|
||||
void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
|
||||
private:
|
||||
void (_Tp::*_M_f)() const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp, class _Arg>
|
||||
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
|
||||
public:
|
||||
explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
|
||||
void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
|
||||
private:
|
||||
void (_Tp::*_M_f)(_Arg);
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp, class _Arg>
|
||||
class const_mem_fun1_t<void, _Tp, _Arg>
|
||||
: public binary_function<const _Tp*,_Arg,void> {
|
||||
public:
|
||||
explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
|
||||
void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
|
||||
private:
|
||||
void (_Tp::*_M_f)(_Arg) const;
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp, class _Arg>
|
||||
class mem_fun1_ref_t<void, _Tp, _Arg>
|
||||
: public binary_function<_Tp,_Arg,void> {
|
||||
public:
|
||||
explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
|
||||
void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
|
||||
private:
|
||||
void (_Tp::*_M_f)(_Arg);
|
||||
};
|
||||
|
||||
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink.
|
||||
template <class _Tp, class _Arg>
|
||||
class const_mem_fun1_ref_t<void, _Tp, _Arg>
|
||||
: public binary_function<_Tp,_Arg,void> {
|
||||
public:
|
||||
explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
|
||||
void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
|
||||
private:
|
||||
void (_Tp::*_M_f)(_Arg) const;
|
||||
};
|
||||
|
||||
|
||||
// Mem_fun adaptor helper functions. There are only two:
|
||||
// mem_fun and mem_fun_ref.
|
||||
|
||||
template <class _Ret, class _Tp>
|
||||
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
|
||||
{ return mem_fun_t<_Ret,_Tp>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp>
|
||||
inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
|
||||
{ return const_mem_fun_t<_Ret,_Tp>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp>
|
||||
inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)())
|
||||
{ return mem_fun_ref_t<_Ret,_Tp>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp>
|
||||
inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
|
||||
{ return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
|
||||
{ return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
|
||||
{ return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
|
||||
{ return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
|
||||
|
||||
template <class _Ret, class _Tp, class _Arg>
|
||||
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
|
||||
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
|
||||
{ return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
|
||||
|
||||
/** @} */
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_FUNCTION_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
308
TBE/MinGW/include/c++/3.2.3/bits/stl_heap.h
Normal file
308
TBE/MinGW/include/c++/3.2.3/bits/stl_heap.h
Normal file
@@ -0,0 +1,308 @@
|
||||
// Heap implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_heap.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_HEAP_H
|
||||
#define _CPP_BITS_STL_HEAP_H 1
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap.
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
|
||||
void
|
||||
__push_heap(_RandomAccessIterator __first,
|
||||
_Distance __holeIndex, _Distance __topIndex, _Tp __value)
|
||||
{
|
||||
_Distance __parent = (__holeIndex - 1) / 2;
|
||||
while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
|
||||
*(__first + __holeIndex) = *(__first + __parent);
|
||||
__holeIndex = __parent;
|
||||
__parent = (__holeIndex - 1) / 2;
|
||||
}
|
||||
*(__first + __holeIndex) = __value;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator>
|
||||
inline void
|
||||
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
||||
_ValueType;
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
||||
_DistanceType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
|
||||
|
||||
__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0),
|
||||
_ValueType(*(__last - 1)));
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
|
||||
typename _Compare>
|
||||
void
|
||||
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
||||
_Distance __topIndex, _Tp __value, _Compare __comp)
|
||||
{
|
||||
_Distance __parent = (__holeIndex - 1) / 2;
|
||||
while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
|
||||
*(__first + __holeIndex) = *(__first + __parent);
|
||||
__holeIndex = __parent;
|
||||
__parent = (__holeIndex - 1) / 2;
|
||||
}
|
||||
*(__first + __holeIndex) = __value;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Compare>
|
||||
inline void
|
||||
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
_Compare __comp)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
||||
_ValueType;
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
||||
_DistanceType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
|
||||
__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0),
|
||||
_ValueType(*(__last - 1)), __comp);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
|
||||
void
|
||||
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
||||
_Distance __len, _Tp __value)
|
||||
{
|
||||
_Distance __topIndex = __holeIndex;
|
||||
_Distance __secondChild = 2 * __holeIndex + 2;
|
||||
while (__secondChild < __len) {
|
||||
if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
|
||||
__secondChild--;
|
||||
*(__first + __holeIndex) = *(__first + __secondChild);
|
||||
__holeIndex = __secondChild;
|
||||
__secondChild = 2 * (__secondChild + 1);
|
||||
}
|
||||
if (__secondChild == __len) {
|
||||
*(__first + __holeIndex) = *(__first + (__secondChild - 1));
|
||||
__holeIndex = __secondChild - 1;
|
||||
}
|
||||
__push_heap(__first, __holeIndex, __topIndex, __value);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Tp>
|
||||
inline void
|
||||
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
_RandomAccessIterator __result, _Tp __value)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
|
||||
*__result = *__first;
|
||||
__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator>
|
||||
inline void
|
||||
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
|
||||
|
||||
__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)));
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Distance,
|
||||
typename _Tp, typename _Compare>
|
||||
void
|
||||
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
||||
_Distance __len, _Tp __value, _Compare __comp)
|
||||
{
|
||||
_Distance __topIndex = __holeIndex;
|
||||
_Distance __secondChild = 2 * __holeIndex + 2;
|
||||
while (__secondChild < __len) {
|
||||
if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
|
||||
__secondChild--;
|
||||
*(__first + __holeIndex) = *(__first + __secondChild);
|
||||
__holeIndex = __secondChild;
|
||||
__secondChild = 2 * (__secondChild + 1);
|
||||
}
|
||||
if (__secondChild == __len) {
|
||||
*(__first + __holeIndex) = *(__first + (__secondChild - 1));
|
||||
__holeIndex = __secondChild - 1;
|
||||
}
|
||||
__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
|
||||
inline void
|
||||
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
_RandomAccessIterator __result, _Tp __value, _Compare __comp)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
|
||||
*__result = *__first;
|
||||
__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
|
||||
__value, __comp);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Compare>
|
||||
inline void
|
||||
pop_heap(_RandomAccessIterator __first,
|
||||
_RandomAccessIterator __last, _Compare __comp)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
|
||||
__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)), __comp);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator>
|
||||
void
|
||||
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
||||
_ValueType;
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
||||
_DistanceType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
|
||||
|
||||
if (__last - __first < 2) return;
|
||||
_DistanceType __len = __last - __first;
|
||||
_DistanceType __parent = (__len - 2)/2;
|
||||
|
||||
while (true) {
|
||||
__adjust_heap(__first, __parent, __len, _ValueType(*(__first + __parent)));
|
||||
if (__parent == 0) return;
|
||||
__parent--;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Compare>
|
||||
inline void
|
||||
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
_Compare __comp)
|
||||
{
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
||||
_ValueType;
|
||||
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
||||
_DistanceType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
|
||||
if (__last - __first < 2) return;
|
||||
_DistanceType __len = __last - __first;
|
||||
_DistanceType __parent = (__len - 2)/2;
|
||||
|
||||
while (true) {
|
||||
__adjust_heap(__first, __parent, __len,
|
||||
_ValueType(*(__first + __parent)), __comp);
|
||||
if (__parent == 0) return;
|
||||
__parent--;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator>
|
||||
void
|
||||
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
__glibcpp_function_requires(_LessThanComparableConcept<
|
||||
typename iterator_traits<_RandomAccessIterator>::value_type>)
|
||||
|
||||
while (__last - __first > 1)
|
||||
pop_heap(__first, __last--);
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Compare>
|
||||
void
|
||||
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
_Compare __comp)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
|
||||
_RandomAccessIterator>)
|
||||
|
||||
while (__last - __first > 1)
|
||||
pop_heap(__first, __last--, __comp);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_HEAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
739
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator.h
Normal file
739
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator.h
Normal file
@@ -0,0 +1,739 @@
|
||||
// Iterators -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_iterator.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*
|
||||
* This file implements reverse_iterator, back_insert_iterator,
|
||||
* front_insert_iterator, insert_iterator, __normal_iterator, and their
|
||||
* supporting functions and overloaded operators.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_ITERATOR_H
|
||||
#define __GLIBCPP_INTERNAL_ITERATOR_H
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 24.4.1 Reverse iterators
|
||||
/**
|
||||
* "Bidirectional and random access iterators have corresponding reverse
|
||||
* %iterator adaptors that iterate through the data structure in the
|
||||
* opposite direction. They have the same signatures as the corresponding
|
||||
* iterators. The fundamental relation between a reverse %iterator and its
|
||||
* corresponding %iterator @c i is established by the identity:
|
||||
* @code
|
||||
* &*(reverse_iterator(i)) == &*(i - 1)
|
||||
* @endcode
|
||||
*
|
||||
* This mapping is dictated by the fact that while there is always a
|
||||
* pointer past the end of an array, there might not be a valid pointer
|
||||
* before the beginning of an array." [24.4.1]/1,2
|
||||
*
|
||||
* Reverse iterators can be tricky and surprising at first. Their
|
||||
* semantics make sense, however, and the trickiness is a side effect of
|
||||
* the requirement that the iterators must be safe.
|
||||
*/
|
||||
template<typename _Iterator>
|
||||
class reverse_iterator
|
||||
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
|
||||
typename iterator_traits<_Iterator>::value_type,
|
||||
typename iterator_traits<_Iterator>::difference_type,
|
||||
typename iterator_traits<_Iterator>::pointer,
|
||||
typename iterator_traits<_Iterator>::reference>
|
||||
{
|
||||
protected:
|
||||
_Iterator current;
|
||||
|
||||
public:
|
||||
typedef _Iterator iterator_type;
|
||||
typedef typename iterator_traits<_Iterator>::difference_type
|
||||
difference_type;
|
||||
typedef typename iterator_traits<_Iterator>::reference reference;
|
||||
typedef typename iterator_traits<_Iterator>::pointer pointer;
|
||||
|
||||
public:
|
||||
/**
|
||||
* The default constructor gives an undefined state to this %iterator.
|
||||
*/
|
||||
reverse_iterator() { }
|
||||
|
||||
/**
|
||||
* This %iterator will move in the opposite direction that @p x does.
|
||||
*/
|
||||
explicit
|
||||
reverse_iterator(iterator_type __x) : current(__x) { }
|
||||
|
||||
/**
|
||||
* The copy constructor is normal.
|
||||
*/
|
||||
reverse_iterator(const reverse_iterator& __x)
|
||||
: current(__x.current) { }
|
||||
|
||||
/**
|
||||
* A reverse_iterator across other types can be copied in the normal
|
||||
* fashion.
|
||||
*/
|
||||
template<typename _Iter>
|
||||
reverse_iterator(const reverse_iterator<_Iter>& __x)
|
||||
: current(__x.base()) { }
|
||||
|
||||
/**
|
||||
* @return @c current, the %iterator used for underlying work.
|
||||
*/
|
||||
iterator_type
|
||||
base() const { return current; }
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reference
|
||||
operator*() const
|
||||
{
|
||||
_Iterator __tmp = current;
|
||||
return *--__tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
pointer
|
||||
operator->() const { return &(operator*()); }
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator&
|
||||
operator++()
|
||||
{
|
||||
--current;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator
|
||||
operator++(int)
|
||||
{
|
||||
reverse_iterator __tmp = *this;
|
||||
--current;
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator&
|
||||
operator--()
|
||||
{
|
||||
++current;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator operator--(int)
|
||||
{
|
||||
reverse_iterator __tmp = *this;
|
||||
++current;
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator
|
||||
operator+(difference_type __n) const
|
||||
{ return reverse_iterator(current - __n); }
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator&
|
||||
operator+=(difference_type __n)
|
||||
{
|
||||
current -= __n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator
|
||||
operator-(difference_type __n) const
|
||||
{ return reverse_iterator(current + __n); }
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reverse_iterator&
|
||||
operator-=(difference_type __n)
|
||||
{
|
||||
current += __n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return TODO
|
||||
*
|
||||
* @doctodo
|
||||
*/
|
||||
reference
|
||||
operator[](difference_type __n) const { return *(*this + __n); }
|
||||
};
|
||||
|
||||
//@{
|
||||
/**
|
||||
* @param x A %reverse_iterator.
|
||||
* @param y A %reverse_iterator.
|
||||
* @return A simple bool.
|
||||
*
|
||||
* Reverse iterators forward many operations to their underlying base()
|
||||
* iterators. Others are implemented in terms of one another.
|
||||
*
|
||||
*/
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator==(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return __x.base() == __y.base(); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator<(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return __y.base() < __x.base(); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator!=(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return !(__x == __y); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator>(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return __y < __x; }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator<=(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return !(__y < __x); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline bool
|
||||
operator>=(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return !(__x < __y); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline typename reverse_iterator<_Iterator>::difference_type
|
||||
operator-(const reverse_iterator<_Iterator>& __x,
|
||||
const reverse_iterator<_Iterator>& __y)
|
||||
{ return __y.base() - __x.base(); }
|
||||
|
||||
template<typename _Iterator>
|
||||
inline reverse_iterator<_Iterator>
|
||||
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
|
||||
const reverse_iterator<_Iterator>& __x)
|
||||
{ return reverse_iterator<_Iterator>(__x.base() - __n); }
|
||||
//@}
|
||||
|
||||
// 24.4.2.2.1 back_insert_iterator
|
||||
/**
|
||||
* These are output iterators, constructed from a container-of-T.
|
||||
* Assigning a T to the iterator appends it to the container using
|
||||
* push_back.
|
||||
*
|
||||
* Tip: Using the back_inserter function to create these iterators can
|
||||
* save typing.
|
||||
*/
|
||||
template<typename _Container>
|
||||
class back_insert_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
protected:
|
||||
_Container* container;
|
||||
|
||||
public:
|
||||
/// A nested typedef for the type of whatever container you used.
|
||||
typedef _Container container_type;
|
||||
|
||||
/// The only way to create this %iterator is with a container.
|
||||
explicit
|
||||
back_insert_iterator(_Container& __x) : container(&__x) { }
|
||||
|
||||
/**
|
||||
* @param value An instance of whatever type
|
||||
* container_type::const_reference is; presumably a
|
||||
* reference-to-const T for container<T>.
|
||||
* @return This %iterator, for chained operations.
|
||||
*
|
||||
* This kind of %iterator doesn't really have a "position" in the
|
||||
* container (you can think of the position as being permanently at
|
||||
* the end, if you like). Assigning a value to the %iterator will
|
||||
* always append the value to the end of the container.
|
||||
*/
|
||||
back_insert_iterator&
|
||||
operator=(typename _Container::const_reference __value)
|
||||
{
|
||||
container->push_back(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Simply returns *this.
|
||||
back_insert_iterator&
|
||||
operator*() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
back_insert_iterator&
|
||||
operator++() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
back_insert_iterator
|
||||
operator++(int) { return *this; }
|
||||
};
|
||||
|
||||
/**
|
||||
* @param x A container of arbitrary type.
|
||||
* @return An instance of back_insert_iterator working on @p x.
|
||||
*
|
||||
* This wrapper function helps in creating back_insert_iterator instances.
|
||||
* Typing the name of the %iterator requires knowing the precise full
|
||||
* type of the container, which can be tedious and impedes generic
|
||||
* programming. Using this function lets you take advantage of automatic
|
||||
* template parameter deduction, making the compiler match the correct
|
||||
* types for you.
|
||||
*/
|
||||
template<typename _Container>
|
||||
inline back_insert_iterator<_Container>
|
||||
back_inserter(_Container& __x)
|
||||
{ return back_insert_iterator<_Container>(__x); }
|
||||
|
||||
/**
|
||||
* These are output iterators, constructed from a container-of-T.
|
||||
* Assigning a T to the iterator prepends it to the container using
|
||||
* push_front.
|
||||
*
|
||||
* Tip: Using the front_inserter function to create these iterators can
|
||||
* save typing.
|
||||
*/
|
||||
template<typename _Container>
|
||||
class front_insert_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
protected:
|
||||
_Container* container;
|
||||
|
||||
public:
|
||||
/// A nested typedef for the type of whatever container you used.
|
||||
typedef _Container container_type;
|
||||
|
||||
/// The only way to create this %iterator is with a container.
|
||||
explicit front_insert_iterator(_Container& __x) : container(&__x) { }
|
||||
|
||||
/**
|
||||
* @param value An instance of whatever type
|
||||
* container_type::const_reference is; presumably a
|
||||
* reference-to-const T for container<T>.
|
||||
* @return This %iterator, for chained operations.
|
||||
*
|
||||
* This kind of %iterator doesn't really have a "position" in the
|
||||
* container (you can think of the position as being permanently at
|
||||
* the front, if you like). Assigning a value to the %iterator will
|
||||
* always prepend the value to the front of the container.
|
||||
*/
|
||||
front_insert_iterator&
|
||||
operator=(typename _Container::const_reference __value)
|
||||
{
|
||||
container->push_front(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Simply returns *this.
|
||||
front_insert_iterator&
|
||||
operator*() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
front_insert_iterator&
|
||||
operator++() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
front_insert_iterator
|
||||
operator++(int) { return *this; }
|
||||
};
|
||||
|
||||
/**
|
||||
* @param x A container of arbitrary type.
|
||||
* @return An instance of front_insert_iterator working on @p x.
|
||||
*
|
||||
* This wrapper function helps in creating front_insert_iterator instances.
|
||||
* Typing the name of the %iterator requires knowing the precise full
|
||||
* type of the container, which can be tedious and impedes generic
|
||||
* programming. Using this function lets you take advantage of automatic
|
||||
* template parameter deduction, making the compiler match the correct
|
||||
* types for you.
|
||||
*/
|
||||
template<typename _Container>
|
||||
inline front_insert_iterator<_Container>
|
||||
front_inserter(_Container& __x)
|
||||
{ return front_insert_iterator<_Container>(__x); }
|
||||
|
||||
/**
|
||||
* These are output iterators, constructed from a container-of-T.
|
||||
* Assigning a T to the iterator inserts it in the container at the
|
||||
* %iterator's position, rather than overwriting the value at that
|
||||
* position.
|
||||
*
|
||||
* (Sequences will actually insert a @e copy of the value before the
|
||||
* %iterator's position.)
|
||||
*
|
||||
* Tip: Using the inserter function to create these iterators can
|
||||
* save typing.
|
||||
*/
|
||||
template<typename _Container>
|
||||
class insert_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
protected:
|
||||
_Container* container;
|
||||
typename _Container::iterator iter;
|
||||
|
||||
public:
|
||||
/// A nested typedef for the type of whatever container you used.
|
||||
typedef _Container container_type;
|
||||
|
||||
/**
|
||||
* The only way to create this %iterator is with a container and an
|
||||
* initial position (a normal %iterator into the container).
|
||||
*/
|
||||
insert_iterator(_Container& __x, typename _Container::iterator __i)
|
||||
: container(&__x), iter(__i) {}
|
||||
|
||||
/**
|
||||
* @param value An instance of whatever type
|
||||
* container_type::const_reference is; presumably a
|
||||
* reference-to-const T for container<T>.
|
||||
* @return This %iterator, for chained operations.
|
||||
*
|
||||
* This kind of %iterator maintains its own position in the
|
||||
* container. Assigning a value to the %iterator will insert the
|
||||
* value into the container at the place before the %iterator.
|
||||
*
|
||||
* The position is maintained such that subsequent assignments will
|
||||
* insert values immediately after one another. For example,
|
||||
* @code
|
||||
* // vector v contains A and Z
|
||||
*
|
||||
* insert_iterator i (v, ++v.begin());
|
||||
* i = 1;
|
||||
* i = 2;
|
||||
* i = 3;
|
||||
*
|
||||
* // vector v contains A, 1, 2, 3, and Z
|
||||
* @endcode
|
||||
*/
|
||||
insert_iterator&
|
||||
operator=(const typename _Container::const_reference __value)
|
||||
{
|
||||
iter = container->insert(iter, __value);
|
||||
++iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Simply returns *this.
|
||||
insert_iterator&
|
||||
operator*() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
insert_iterator&
|
||||
operator++() { return *this; }
|
||||
|
||||
/// Simply returns *this. (This %iterator does not "move".)
|
||||
insert_iterator&
|
||||
operator++(int) { return *this; }
|
||||
};
|
||||
|
||||
/**
|
||||
* @param x A container of arbitrary type.
|
||||
* @return An instance of insert_iterator working on @p x.
|
||||
*
|
||||
* This wrapper function helps in creating insert_iterator instances.
|
||||
* Typing the name of the %iterator requires knowing the precise full
|
||||
* type of the container, which can be tedious and impedes generic
|
||||
* programming. Using this function lets you take advantage of automatic
|
||||
* template parameter deduction, making the compiler match the correct
|
||||
* types for you.
|
||||
*/
|
||||
template<typename _Container, typename _Iterator>
|
||||
inline insert_iterator<_Container>
|
||||
inserter(_Container& __x, _Iterator __i)
|
||||
{
|
||||
return insert_iterator<_Container>(__x,
|
||||
typename _Container::iterator(__i));
|
||||
}
|
||||
} // namespace std
|
||||
|
||||
namespace __gnu_cxx
|
||||
{
|
||||
// This iterator adapter is 'normal' in the sense that it does not
|
||||
// change the semantics of any of the operators of its iterator
|
||||
// parameter. Its primary purpose is to convert an iterator that is
|
||||
// not a class, e.g. a pointer, into an iterator that is a class.
|
||||
// The _Container parameter exists solely so that different containers
|
||||
// using this template can instantiate different types, even if the
|
||||
// _Iterator parameter is the same.
|
||||
using std::iterator_traits;
|
||||
using std::iterator;
|
||||
template<typename _Iterator, typename _Container>
|
||||
class __normal_iterator
|
||||
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
|
||||
typename iterator_traits<_Iterator>::value_type,
|
||||
typename iterator_traits<_Iterator>::difference_type,
|
||||
typename iterator_traits<_Iterator>::pointer,
|
||||
typename iterator_traits<_Iterator>::reference>
|
||||
{
|
||||
protected:
|
||||
_Iterator _M_current;
|
||||
|
||||
public:
|
||||
typedef typename iterator_traits<_Iterator>::difference_type
|
||||
difference_type;
|
||||
typedef typename iterator_traits<_Iterator>::reference reference;
|
||||
typedef typename iterator_traits<_Iterator>::pointer pointer;
|
||||
|
||||
__normal_iterator() : _M_current(_Iterator()) { }
|
||||
|
||||
explicit
|
||||
__normal_iterator(const _Iterator& __i) : _M_current(__i) { }
|
||||
|
||||
// Allow iterator to const_iterator conversion
|
||||
template<typename _Iter>
|
||||
inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
|
||||
: _M_current(__i.base()) { }
|
||||
|
||||
// Forward iterator requirements
|
||||
reference
|
||||
operator*() const { return *_M_current; }
|
||||
|
||||
pointer
|
||||
operator->() const { return _M_current; }
|
||||
|
||||
__normal_iterator&
|
||||
operator++() { ++_M_current; return *this; }
|
||||
|
||||
__normal_iterator
|
||||
operator++(int) { return __normal_iterator(_M_current++); }
|
||||
|
||||
// Bidirectional iterator requirements
|
||||
__normal_iterator&
|
||||
operator--() { --_M_current; return *this; }
|
||||
|
||||
__normal_iterator
|
||||
operator--(int) { return __normal_iterator(_M_current--); }
|
||||
|
||||
// Random access iterator requirements
|
||||
reference
|
||||
operator[](const difference_type& __n) const
|
||||
{ return _M_current[__n]; }
|
||||
|
||||
__normal_iterator&
|
||||
operator+=(const difference_type& __n)
|
||||
{ _M_current += __n; return *this; }
|
||||
|
||||
__normal_iterator
|
||||
operator+(const difference_type& __n) const
|
||||
{ return __normal_iterator(_M_current + __n); }
|
||||
|
||||
__normal_iterator&
|
||||
operator-=(const difference_type& __n)
|
||||
{ _M_current -= __n; return *this; }
|
||||
|
||||
__normal_iterator
|
||||
operator-(const difference_type& __n) const
|
||||
{ return __normal_iterator(_M_current - __n); }
|
||||
|
||||
const _Iterator&
|
||||
base() const { return _M_current; }
|
||||
};
|
||||
|
||||
// Note: In what follows, the left- and right-hand-side iterators are
|
||||
// allowed to vary in types (conceptually in cv-qualification) so that
|
||||
// comparaison between cv-qualified and non-cv-qualified iterators be
|
||||
// valid. However, the greedy and unfriendly operators in std::rel_ops
|
||||
// will make overload resolution ambiguous (when in scope) if we don't
|
||||
// provide overloads whose operands are of the same type. Can someone
|
||||
// remind me what generic programming is about? -- Gaby
|
||||
|
||||
// Forward iterator requirements
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() == __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() == __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() != __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() != __rhs.base(); }
|
||||
|
||||
// Random access iterator requirements
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() < __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() < __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() > __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() > __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() <= __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() <= __rhs.base(); }
|
||||
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline bool
|
||||
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() >= __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline bool
|
||||
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
||||
const __normal_iterator<_Iterator, _Container>& __rhs)
|
||||
{ return __lhs.base() >= __rhs.base(); }
|
||||
|
||||
// _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// According to the resolution of DR179 not only the various comparison
|
||||
// operators but also operator- must accept mixed iterator/const_iterator
|
||||
// parameters.
|
||||
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
||||
inline typename __normal_iterator<_IteratorL, _Container>::difference_type
|
||||
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
||||
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
||||
{ return __lhs.base() - __rhs.base(); }
|
||||
|
||||
template<typename _Iterator, typename _Container>
|
||||
inline __normal_iterator<_Iterator, _Container>
|
||||
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
|
||||
const __normal_iterator<_Iterator, _Container>& __i)
|
||||
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
179
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator_base_funcs.h
Normal file
179
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator_base_funcs.h
Normal file
@@ -0,0 +1,179 @@
|
||||
// Functions used by iterators -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_iterator_base_funcs.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*
|
||||
* This file contains all of the general iterator-related utility
|
||||
* functions, such as distance() and advance().
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_ITERATOR_BASE_FUNCS_H
|
||||
#define __GLIBCPP_INTERNAL_ITERATOR_BASE_FUNCS_H
|
||||
|
||||
#pragma GCC system_header
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
// Since this entire file is within namespace std, there's no reason to
|
||||
// waste two spaces along the left column. Thus the leading indentation is
|
||||
// slightly violated from here on.
|
||||
namespace std
|
||||
{
|
||||
template<typename _InputIterator>
|
||||
inline typename iterator_traits<_InputIterator>::difference_type
|
||||
__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
|
||||
typename iterator_traits<_InputIterator>::difference_type __n = 0;
|
||||
while (__first != __last) {
|
||||
++__first; ++__n;
|
||||
}
|
||||
return __n;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator>
|
||||
inline typename iterator_traits<_RandomAccessIterator>::difference_type
|
||||
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
||||
random_access_iterator_tag)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
|
||||
return __last - __first;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief A generalization of pointer arithmetic.
|
||||
* @param first An input iterator.
|
||||
* @param last An input iterator.
|
||||
* @return The distance between them.
|
||||
*
|
||||
* Returns @c n such that first + n == last. This requires that @p last
|
||||
* must be reachable from @p first. Note that @c n may be negative.
|
||||
*
|
||||
* For random access iterators, this uses their @c + and @c - operations
|
||||
* and are constant time. For other %iterator classes they are linear time.
|
||||
*/
|
||||
template<typename _InputIterator>
|
||||
inline typename iterator_traits<_InputIterator>::difference_type
|
||||
distance(_InputIterator __first, _InputIterator __last)
|
||||
{
|
||||
// concept requirements -- taken care of in __distance
|
||||
return __distance(__first, __last, __iterator_category(__first));
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _Distance>
|
||||
inline void
|
||||
__advance(_InputIter& __i, _Distance __n, input_iterator_tag)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIter>)
|
||||
while (__n--) ++__i;
|
||||
}
|
||||
|
||||
template<typename _BidirectionalIterator, typename _Distance>
|
||||
inline void
|
||||
__advance(_BidirectionalIterator& __i, _Distance __n,
|
||||
bidirectional_iterator_tag)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
|
||||
|
||||
if (__n > 0)
|
||||
while (__n--) ++__i;
|
||||
else
|
||||
while (__n++) --__i;
|
||||
}
|
||||
|
||||
template<typename _RandomAccessIterator, typename _Distance>
|
||||
inline void
|
||||
__advance(_RandomAccessIterator& __i, _Distance __n,
|
||||
random_access_iterator_tag)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
|
||||
__i += __n;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief A generalization of pointer arithmetic.
|
||||
* @param i An input iterator.
|
||||
* @param n The "delta" by which to change @p i.
|
||||
* @return Nothing.
|
||||
*
|
||||
* This increments @p i by @p n. For bidirectional and random access
|
||||
* iterators, @p n may be negative, in which case @p i is decremented.
|
||||
*
|
||||
* For random access iterators, this uses their @c + and @c - operations
|
||||
* and are constant time. For other %iterator classes they are linear time.
|
||||
*/
|
||||
template<typename _InputIterator, typename _Distance>
|
||||
inline void
|
||||
advance(_InputIterator& __i, _Distance __n)
|
||||
{
|
||||
// concept requirements -- taken care of in __advance
|
||||
__advance(__i, __n, __iterator_category(__i));
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_ITERATOR_BASE_FUNCS_H */
|
||||
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
162
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator_base_types.h
Normal file
162
TBE/MinGW/include/c++/3.2.3/bits/stl_iterator_base_types.h
Normal file
@@ -0,0 +1,162 @@
|
||||
// Types used in iterator implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-1998
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_iterator_base_types.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*
|
||||
* This file contains all of the general iterator-related utility types,
|
||||
* such as iterator_traits and struct iterator.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_ITERATOR_BASE_TYPES_H
|
||||
#define __GLIBCPP_INTERNAL_ITERATOR_BASE_TYPES_H
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* @defgroup iterator_tags Iterator Tags
|
||||
* These are empty types, used to distinguish different iterators. The
|
||||
* distinction is not made by what they contain, but simply by what they
|
||||
* are. Different underlying algorithms can then be used based on the
|
||||
* different operations supporetd by different iterator types.
|
||||
* @{
|
||||
*/
|
||||
/// Marking input iterators.
|
||||
struct input_iterator_tag {};
|
||||
/// Marking output iterators.
|
||||
struct output_iterator_tag {};
|
||||
/// Forward iterators support a superset of input iterator operations.
|
||||
struct forward_iterator_tag : public input_iterator_tag {};
|
||||
/// Bidirectional iterators support a superset of forward iterator operations.
|
||||
struct bidirectional_iterator_tag : public forward_iterator_tag {};
|
||||
/// Random-access iterators support a superset of bidirectional iterator operations.
|
||||
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
|
||||
//@}
|
||||
|
||||
|
||||
/**
|
||||
* This class does nothing but define nested typedefs. %Iterator classes
|
||||
* can inherit from this class to save some work. The typedefs are then
|
||||
* used in specializations and overloading.
|
||||
*
|
||||
* In particular, there are no default implementations of requirements
|
||||
* such as @c operator++ and the like. (How could there be?)
|
||||
*/
|
||||
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
|
||||
typename _Pointer = _Tp*, typename _Reference = _Tp&>
|
||||
struct iterator {
|
||||
/// One of the @link iterator_tags tag types@endlink.
|
||||
typedef _Category iterator_category;
|
||||
/// The type "pointed to" by the iterator.
|
||||
typedef _Tp value_type;
|
||||
/// Distance between iterators is represented as this type.
|
||||
typedef _Distance difference_type;
|
||||
/// This type represents a pointer-to-value_type.
|
||||
typedef _Pointer pointer;
|
||||
/// This type represents a reference-to-value_type.
|
||||
typedef _Reference reference;
|
||||
};
|
||||
|
||||
/**
|
||||
* This class does nothing but define nested typedefs. The general
|
||||
* version simply "forwards" the nested typedefs from the Iterator
|
||||
* argument. Specialized versions for pointers and pointers-to-const
|
||||
* provide tighter, more correct semantics.
|
||||
*/
|
||||
template<typename _Iterator>
|
||||
struct iterator_traits {
|
||||
typedef typename _Iterator::iterator_category iterator_category;
|
||||
typedef typename _Iterator::value_type value_type;
|
||||
typedef typename _Iterator::difference_type difference_type;
|
||||
typedef typename _Iterator::pointer pointer;
|
||||
typedef typename _Iterator::reference reference;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct iterator_traits<_Tp*> {
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef _Tp* pointer;
|
||||
typedef _Tp& reference;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct iterator_traits<const _Tp*> {
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
typedef _Tp value_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef const _Tp* pointer;
|
||||
typedef const _Tp& reference;
|
||||
};
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* This function is not a part of the C++ standard but is syntactic
|
||||
* sugar for internal library use only.
|
||||
* @endif
|
||||
*/
|
||||
template<typename _Iter>
|
||||
inline typename iterator_traits<_Iter>::iterator_category
|
||||
__iterator_category(const _Iter&)
|
||||
{ return typename iterator_traits<_Iter>::iterator_category(); }
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_ITERATOR_BASE_TYPES_H */
|
||||
|
||||
989
TBE/MinGW/include/c++/3.2.3/bits/stl_list.h
Normal file
989
TBE/MinGW/include/c++/3.2.3/bits/stl_list.h
Normal file
@@ -0,0 +1,989 @@
|
||||
// List implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_list.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_LIST_H
|
||||
#define __GLIBCPP_INTERNAL_LIST_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
struct _List_node_base
|
||||
{
|
||||
_List_node_base* _M_next;
|
||||
_List_node_base* _M_prev;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _List_node : public _List_node_base
|
||||
{
|
||||
_Tp _M_data;
|
||||
};
|
||||
|
||||
struct _List_iterator_base
|
||||
{
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef bidirectional_iterator_tag iterator_category;
|
||||
|
||||
_List_node_base* _M_node;
|
||||
|
||||
_List_iterator_base(_List_node_base* __x)
|
||||
: _M_node(__x)
|
||||
{ }
|
||||
|
||||
_List_iterator_base()
|
||||
{ }
|
||||
|
||||
void
|
||||
_M_incr()
|
||||
{ _M_node = _M_node->_M_next; }
|
||||
|
||||
void
|
||||
_M_decr()
|
||||
{ _M_node = _M_node->_M_prev; }
|
||||
|
||||
bool
|
||||
operator==(const _List_iterator_base& __x) const
|
||||
{ return _M_node == __x._M_node; }
|
||||
|
||||
bool
|
||||
operator!=(const _List_iterator_base& __x) const
|
||||
{ return _M_node != __x._M_node; }
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Ref, typename _Ptr>
|
||||
struct _List_iterator : public _List_iterator_base
|
||||
{
|
||||
typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
|
||||
typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
|
||||
typedef _List_iterator<_Tp,_Ref,_Ptr> _Self;
|
||||
|
||||
typedef _Tp value_type;
|
||||
typedef _Ptr pointer;
|
||||
typedef _Ref reference;
|
||||
typedef _List_node<_Tp> _Node;
|
||||
|
||||
_List_iterator(_Node* __x)
|
||||
: _List_iterator_base(__x)
|
||||
{ }
|
||||
|
||||
_List_iterator()
|
||||
{ }
|
||||
|
||||
_List_iterator(const iterator& __x)
|
||||
: _List_iterator_base(__x._M_node)
|
||||
{ }
|
||||
|
||||
reference
|
||||
operator*() const
|
||||
{ return ((_Node*) _M_node)->_M_data; }
|
||||
|
||||
pointer
|
||||
operator->() const
|
||||
{ return &(operator*()); }
|
||||
|
||||
_Self&
|
||||
operator++()
|
||||
{
|
||||
this->_M_incr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
_Self
|
||||
operator++(int)
|
||||
{
|
||||
_Self __tmp = *this;
|
||||
this->_M_incr();
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
_Self&
|
||||
operator--()
|
||||
{
|
||||
this->_M_decr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
_Self
|
||||
operator--(int)
|
||||
{
|
||||
_Self __tmp = *this;
|
||||
this->_M_decr();
|
||||
return __tmp;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Base class that encapsulates details of allocators. Three cases:
|
||||
// an ordinary standard-conforming allocator, a standard-conforming
|
||||
// allocator with no non-static data, and an SGI-style allocator.
|
||||
// This complexity is necessary only because we're worrying about backward
|
||||
// compatibility and because we want to avoid wasting storage on an
|
||||
// allocator instance if it isn't necessary.
|
||||
|
||||
|
||||
// Base for general standard-conforming allocators.
|
||||
template<typename _Tp, typename _Allocator, bool _IsStatic>
|
||||
class _List_alloc_base
|
||||
{
|
||||
public:
|
||||
typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
|
||||
allocator_type;
|
||||
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _Node_allocator; }
|
||||
|
||||
_List_alloc_base(const allocator_type& __a)
|
||||
: _Node_allocator(__a)
|
||||
{ }
|
||||
|
||||
protected:
|
||||
_List_node<_Tp>*
|
||||
_M_get_node()
|
||||
{ return _Node_allocator.allocate(1); }
|
||||
|
||||
void
|
||||
_M_put_node(_List_node<_Tp>* __p)
|
||||
{ _Node_allocator.deallocate(__p, 1); }
|
||||
|
||||
protected:
|
||||
typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type
|
||||
_Node_allocator;
|
||||
|
||||
_List_node<_Tp>* _M_node;
|
||||
};
|
||||
|
||||
// Specialization for instanceless allocators.
|
||||
|
||||
template<typename _Tp, typename _Allocator>
|
||||
class _List_alloc_base<_Tp, _Allocator, true>
|
||||
{
|
||||
public:
|
||||
typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
|
||||
allocator_type;
|
||||
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return allocator_type(); }
|
||||
|
||||
_List_alloc_base(const allocator_type&)
|
||||
{ }
|
||||
|
||||
protected:
|
||||
typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type
|
||||
_Alloc_type;
|
||||
|
||||
_List_node<_Tp>*
|
||||
_M_get_node()
|
||||
{ return _Alloc_type::allocate(1); }
|
||||
|
||||
void
|
||||
_M_put_node(_List_node<_Tp>* __p)
|
||||
{ _Alloc_type::deallocate(__p, 1); }
|
||||
|
||||
protected:
|
||||
_List_node<_Tp>* _M_node;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
class _List_base
|
||||
: public _List_alloc_base<_Tp, _Alloc,
|
||||
_Alloc_traits<_Tp, _Alloc>::_S_instanceless>
|
||||
{
|
||||
public:
|
||||
typedef _List_alloc_base<_Tp, _Alloc,
|
||||
_Alloc_traits<_Tp, _Alloc>::_S_instanceless>
|
||||
_Base;
|
||||
typedef typename _Base::allocator_type allocator_type;
|
||||
|
||||
_List_base(const allocator_type& __a)
|
||||
: _Base(__a)
|
||||
{
|
||||
_M_node = _M_get_node();
|
||||
_M_node->_M_next = _M_node;
|
||||
_M_node->_M_prev = _M_node;
|
||||
}
|
||||
|
||||
~_List_base()
|
||||
{
|
||||
clear();
|
||||
_M_put_node(_M_node);
|
||||
}
|
||||
|
||||
void clear();
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup Containers
|
||||
* @ingroup Sequences
|
||||
*
|
||||
* Meets the requirements of a <a href="tables.html#65">container</a>, a
|
||||
* <a href="tables.html#66">reversible container</a>, and a
|
||||
* <a href="tables.html#67">sequence</a>, including the
|
||||
* <a href="tables.html#68">optional sequence requirements</a> with the
|
||||
* %exception of @c at and @c operator[].
|
||||
*
|
||||
* @doctodo
|
||||
*
|
||||
*/
|
||||
template<typename _Tp, typename _Alloc = allocator<_Tp> >
|
||||
class list : protected _List_base<_Tp, _Alloc>
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
|
||||
typedef _List_base<_Tp, _Alloc> _Base;
|
||||
protected:
|
||||
typedef void* _Void_pointer;
|
||||
|
||||
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 _List_node<_Tp> _Node;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
typedef typename _Base::allocator_type allocator_type;
|
||||
|
||||
typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
|
||||
typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
|
||||
|
||||
typedef reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
typedef reverse_iterator<iterator> reverse_iterator;
|
||||
|
||||
protected:
|
||||
using _Base::_M_node;
|
||||
using _Base::_M_put_node;
|
||||
using _Base::_M_get_node;
|
||||
|
||||
protected:
|
||||
_Node*
|
||||
_M_create_node(const _Tp& __x)
|
||||
{
|
||||
_Node* __p = _M_get_node();
|
||||
try {
|
||||
_Construct(&__p->_M_data, __x);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_M_put_node(__p);
|
||||
__throw_exception_again;
|
||||
}
|
||||
return __p;
|
||||
}
|
||||
|
||||
_Node*
|
||||
_M_create_node()
|
||||
{
|
||||
_Node* __p = _M_get_node();
|
||||
try {
|
||||
_Construct(&__p->_M_data);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_M_put_node(__p);
|
||||
__throw_exception_again;
|
||||
}
|
||||
return __p;
|
||||
}
|
||||
|
||||
public:
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _Base::get_allocator(); }
|
||||
|
||||
explicit
|
||||
list(const allocator_type& __a = allocator_type())
|
||||
: _Base(__a)
|
||||
{ }
|
||||
|
||||
iterator
|
||||
begin()
|
||||
{ return static_cast<_Node*>(_M_node->_M_next); }
|
||||
|
||||
const_iterator
|
||||
begin() const
|
||||
{ return static_cast<_Node*>(_M_node->_M_next); }
|
||||
|
||||
iterator
|
||||
end()
|
||||
{ return _M_node; }
|
||||
|
||||
const_iterator
|
||||
end() const
|
||||
{ return _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_node->_M_next == _M_node; }
|
||||
|
||||
size_type
|
||||
size() const
|
||||
{ return distance(begin(), end()); }
|
||||
|
||||
size_type
|
||||
max_size() const
|
||||
{ return size_type(-1); }
|
||||
|
||||
reference
|
||||
front()
|
||||
{ return *begin(); }
|
||||
|
||||
const_reference
|
||||
front() const
|
||||
{ return *begin(); }
|
||||
|
||||
reference
|
||||
back()
|
||||
{ return *(--end()); }
|
||||
|
||||
const_reference
|
||||
back() const
|
||||
{ return *(--end()); }
|
||||
|
||||
void
|
||||
swap(list<_Tp, _Alloc>& __x)
|
||||
{ std::swap(_M_node, __x._M_node); }
|
||||
|
||||
iterator
|
||||
insert(iterator __position, const _Tp& __x)
|
||||
{
|
||||
_Node* __tmp = _M_create_node(__x);
|
||||
__tmp->_M_next = __position._M_node;
|
||||
__tmp->_M_prev = __position._M_node->_M_prev;
|
||||
__position._M_node->_M_prev->_M_next = __tmp;
|
||||
__position._M_node->_M_prev = __tmp;
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
iterator
|
||||
insert(iterator __position)
|
||||
{ return insert(__position, _Tp()); }
|
||||
|
||||
// Check whether it's an integral type. If so, it's not an iterator.
|
||||
template<typename _Integer>
|
||||
void
|
||||
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type)
|
||||
{ _M_fill_insert(__pos, (size_type) __n, (_Tp) __x); }
|
||||
|
||||
template<typename _InputIterator>
|
||||
void
|
||||
_M_insert_dispatch(iterator __pos,
|
||||
_InputIterator __first, _InputIterator __last,
|
||||
__false_type);
|
||||
|
||||
template<typename _InputIterator>
|
||||
void
|
||||
insert(iterator __pos, _InputIterator __first, _InputIterator __last)
|
||||
{
|
||||
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
|
||||
_M_insert_dispatch(__pos, __first, __last, _Integral());
|
||||
}
|
||||
|
||||
void
|
||||
insert(iterator __pos, size_type __n, const _Tp& __x)
|
||||
{ _M_fill_insert(__pos, __n, __x); }
|
||||
|
||||
void
|
||||
_M_fill_insert(iterator __pos, size_type __n, const _Tp& __x);
|
||||
|
||||
void
|
||||
push_front(const _Tp& __x)
|
||||
{ insert(begin(), __x); }
|
||||
|
||||
void
|
||||
push_front()
|
||||
{ insert(begin()); }
|
||||
|
||||
void
|
||||
push_back(const _Tp& __x)
|
||||
{ insert(end(), __x); }
|
||||
|
||||
void
|
||||
push_back()
|
||||
{ insert(end()); }
|
||||
|
||||
iterator
|
||||
erase(iterator __position)
|
||||
{
|
||||
_List_node_base* __next_node = __position._M_node->_M_next;
|
||||
_List_node_base* __prev_node = __position._M_node->_M_prev;
|
||||
_Node* __n = static_cast<_Node*>(__position._M_node);
|
||||
__prev_node->_M_next = __next_node;
|
||||
__next_node->_M_prev = __prev_node;
|
||||
_Destroy(&__n->_M_data);
|
||||
_M_put_node(__n);
|
||||
return iterator(static_cast<_Node*>(__next_node));
|
||||
}
|
||||
|
||||
iterator
|
||||
erase(iterator __first, iterator __last);
|
||||
|
||||
void
|
||||
clear()
|
||||
{ _Base::clear(); }
|
||||
|
||||
void
|
||||
resize(size_type __new_size, const _Tp& __x);
|
||||
|
||||
void
|
||||
resize(size_type __new_size)
|
||||
{ this->resize(__new_size, _Tp()); }
|
||||
|
||||
void
|
||||
pop_front()
|
||||
{ erase(begin()); }
|
||||
|
||||
void
|
||||
pop_back()
|
||||
{
|
||||
iterator __tmp = end();
|
||||
erase(--__tmp);
|
||||
}
|
||||
|
||||
list(size_type __n, const _Tp& __value,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _Base(__a)
|
||||
{ insert(begin(), __n, __value); }
|
||||
|
||||
explicit
|
||||
list(size_type __n)
|
||||
: _Base(allocator_type())
|
||||
{ insert(begin(), __n, _Tp()); }
|
||||
|
||||
// We don't need any dispatching tricks here, because insert does all of
|
||||
// that anyway.
|
||||
template<typename _InputIterator>
|
||||
list(_InputIterator __first, _InputIterator __last,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _Base(__a)
|
||||
{ insert(begin(), __first, __last); }
|
||||
|
||||
list(const list<_Tp, _Alloc>& __x)
|
||||
: _Base(__x.get_allocator())
|
||||
{ insert(begin(), __x.begin(), __x.end()); }
|
||||
|
||||
~list()
|
||||
{ }
|
||||
|
||||
list<_Tp, _Alloc>&
|
||||
operator=(const list<_Tp, _Alloc>& __x);
|
||||
|
||||
public:
|
||||
// assign(), a generalized assignment member function. Two
|
||||
// versions: one that takes a count, and one that takes a range.
|
||||
// The range version is a member template, so we dispatch on whether
|
||||
// or not the type is an integer.
|
||||
|
||||
void
|
||||
assign(size_type __n, const _Tp& __val)
|
||||
{ _M_fill_assign(__n, __val); }
|
||||
|
||||
void
|
||||
_M_fill_assign(size_type __n, const _Tp& __val);
|
||||
|
||||
template<typename _InputIterator>
|
||||
void
|
||||
assign(_InputIterator __first, _InputIterator __last)
|
||||
{
|
||||
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
|
||||
_M_assign_dispatch(__first, __last, _Integral());
|
||||
}
|
||||
|
||||
template<typename _Integer>
|
||||
void
|
||||
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
||||
{ _M_fill_assign((size_type) __n, (_Tp) __val); }
|
||||
|
||||
template<typename _InputIterator>
|
||||
void
|
||||
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
|
||||
__false_type);
|
||||
|
||||
protected:
|
||||
void
|
||||
_M_transfer(iterator __position, iterator __first, iterator __last)
|
||||
{
|
||||
if (__position != __last) {
|
||||
// Remove [first, last) from its old position.
|
||||
__last._M_node->_M_prev->_M_next = __position._M_node;
|
||||
__first._M_node->_M_prev->_M_next = __last._M_node;
|
||||
__position._M_node->_M_prev->_M_next = __first._M_node;
|
||||
|
||||
// Splice [first, last) into its new position.
|
||||
_List_node_base* __tmp = __position._M_node->_M_prev;
|
||||
__position._M_node->_M_prev = __last._M_node->_M_prev;
|
||||
__last._M_node->_M_prev = __first._M_node->_M_prev;
|
||||
__first._M_node->_M_prev = __tmp;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
void
|
||||
splice(iterator __position, list& __x)
|
||||
{
|
||||
if (!__x.empty())
|
||||
this->_M_transfer(__position, __x.begin(), __x.end());
|
||||
}
|
||||
|
||||
void
|
||||
splice(iterator __position, list&, iterator __i)
|
||||
{
|
||||
iterator __j = __i;
|
||||
++__j;
|
||||
if (__position == __i || __position == __j) return;
|
||||
this->_M_transfer(__position, __i, __j);
|
||||
}
|
||||
|
||||
void
|
||||
splice(iterator __position, list&, iterator __first, iterator __last)
|
||||
{
|
||||
if (__first != __last)
|
||||
this->_M_transfer(__position, __first, __last);
|
||||
}
|
||||
|
||||
void
|
||||
remove(const _Tp& __value);
|
||||
|
||||
void
|
||||
unique();
|
||||
|
||||
void
|
||||
merge(list& __x);
|
||||
|
||||
void
|
||||
reverse();
|
||||
|
||||
void
|
||||
sort();
|
||||
|
||||
template<typename _Predicate>
|
||||
void
|
||||
remove_if(_Predicate);
|
||||
|
||||
template<typename _BinaryPredicate>
|
||||
void
|
||||
unique(_BinaryPredicate);
|
||||
|
||||
template<typename _StrictWeakOrdering>
|
||||
void
|
||||
merge(list&, _StrictWeakOrdering);
|
||||
|
||||
template<typename _StrictWeakOrdering>
|
||||
void
|
||||
sort(_StrictWeakOrdering);
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{
|
||||
typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
|
||||
const_iterator __end1 = __x.end();
|
||||
const_iterator __end2 = __y.end();
|
||||
|
||||
const_iterator __i1 = __x.begin();
|
||||
const_iterator __i2 = __y.begin();
|
||||
while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
|
||||
++__i1;
|
||||
++__i2;
|
||||
}
|
||||
return __i1 == __end1 && __i2 == __end2;
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{
|
||||
return lexicographical_compare(__x.begin(), __x.end(),
|
||||
__y.begin(), __y.end());
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator!=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{ return !(__x == __y); }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator>(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{ return __y < __x; }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator<=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{ return !(__y < __x); }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline bool
|
||||
operator>=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
|
||||
{ return !(__x < __y); }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline void
|
||||
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
|
||||
{ __x.swap(__y); }
|
||||
|
||||
// move these to stl_list.tcc
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void _List_base<_Tp,_Alloc>::
|
||||
clear()
|
||||
{
|
||||
_List_node<_Tp>* __cur = static_cast<_List_node<_Tp>*>(_M_node->_M_next);
|
||||
while (__cur != _M_node) {
|
||||
_List_node<_Tp>* __tmp = __cur;
|
||||
__cur = static_cast<_List_node<_Tp>*>(__cur->_M_next);
|
||||
_Destroy(&__tmp->_M_data);
|
||||
_M_put_node(__tmp);
|
||||
}
|
||||
_M_node->_M_next = _M_node;
|
||||
_M_node->_M_prev = _M_node;
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _InputIter>
|
||||
void list<_Tp, _Alloc>::
|
||||
_M_insert_dispatch(iterator __position, _InputIter __first, _InputIter __last,
|
||||
__false_type)
|
||||
{
|
||||
for ( ; __first != __last; ++__first)
|
||||
insert(__position, *__first);
|
||||
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
_M_fill_insert(iterator __position, size_type __n, const _Tp& __x)
|
||||
{
|
||||
for ( ; __n > 0; --__n)
|
||||
insert(__position, __x);
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
typename list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::
|
||||
erase(iterator __first, iterator __last)
|
||||
{
|
||||
while (__first != __last)
|
||||
erase(__first++);
|
||||
return __last;
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
resize(size_type __new_size, const _Tp& __x)
|
||||
{
|
||||
iterator __i = begin();
|
||||
size_type __len = 0;
|
||||
for ( ; __i != end() && __len < __new_size; ++__i, ++__len)
|
||||
;
|
||||
if (__len == __new_size)
|
||||
erase(__i, end());
|
||||
else // __i == end()
|
||||
insert(end(), __new_size - __len, __x);
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
list<_Tp, _Alloc>& list<_Tp, _Alloc>::
|
||||
operator=(const list<_Tp, _Alloc>& __x)
|
||||
{
|
||||
if (this != &__x) {
|
||||
iterator __first1 = begin();
|
||||
iterator __last1 = end();
|
||||
const_iterator __first2 = __x.begin();
|
||||
const_iterator __last2 = __x.end();
|
||||
while (__first1 != __last1 && __first2 != __last2)
|
||||
*__first1++ = *__first2++;
|
||||
if (__first2 == __last2)
|
||||
erase(__first1, __last1);
|
||||
else
|
||||
insert(__last1, __first2, __last2);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
_M_fill_assign(size_type __n, const _Tp& __val) {
|
||||
iterator __i = begin();
|
||||
for ( ; __i != end() && __n > 0; ++__i, --__n)
|
||||
*__i = __val;
|
||||
if (__n > 0)
|
||||
insert(end(), __n, __val);
|
||||
else
|
||||
erase(__i, end());
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _InputIter>
|
||||
void list<_Tp, _Alloc>::
|
||||
_M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type)
|
||||
{
|
||||
iterator __first1 = begin();
|
||||
iterator __last1 = end();
|
||||
for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
|
||||
*__first1 = *__first2;
|
||||
if (__first2 == __last2)
|
||||
erase(__first1, __last1);
|
||||
else
|
||||
insert(__last1, __first2, __last2);
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
remove(const _Tp& __value)
|
||||
{
|
||||
iterator __first = begin();
|
||||
iterator __last = end();
|
||||
while (__first != __last) {
|
||||
iterator __next = __first;
|
||||
++__next;
|
||||
if (*__first == __value) erase(__first);
|
||||
__first = __next;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
unique()
|
||||
{
|
||||
iterator __first = begin();
|
||||
iterator __last = end();
|
||||
if (__first == __last) return;
|
||||
iterator __next = __first;
|
||||
while (++__next != __last) {
|
||||
if (*__first == *__next)
|
||||
erase(__next);
|
||||
else
|
||||
__first = __next;
|
||||
__next = __first;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
merge(list<_Tp, _Alloc>& __x)
|
||||
{
|
||||
iterator __first1 = begin();
|
||||
iterator __last1 = end();
|
||||
iterator __first2 = __x.begin();
|
||||
iterator __last2 = __x.end();
|
||||
while (__first1 != __last1 && __first2 != __last2)
|
||||
if (*__first2 < *__first1) {
|
||||
iterator __next = __first2;
|
||||
_M_transfer(__first1, __first2, ++__next);
|
||||
__first2 = __next;
|
||||
}
|
||||
else
|
||||
++__first1;
|
||||
if (__first2 != __last2) _M_transfer(__last1, __first2, __last2);
|
||||
}
|
||||
|
||||
inline void
|
||||
__List_base_reverse(_List_node_base* __p)
|
||||
{
|
||||
_List_node_base* __tmp = __p;
|
||||
do {
|
||||
std::swap(__tmp->_M_next, __tmp->_M_prev);
|
||||
__tmp = __tmp->_M_prev; // Old next node is now prev.
|
||||
} while (__tmp != __p);
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
inline void list<_Tp, _Alloc>::
|
||||
reverse()
|
||||
{ __List_base_reverse(this->_M_node); }
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
void list<_Tp, _Alloc>::
|
||||
sort()
|
||||
{
|
||||
// Do nothing if the list has length 0 or 1.
|
||||
if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
|
||||
list<_Tp, _Alloc> __carry;
|
||||
list<_Tp, _Alloc> __counter[64];
|
||||
int __fill = 0;
|
||||
while (!empty()) {
|
||||
__carry.splice(__carry.begin(), *this, begin());
|
||||
int __i = 0;
|
||||
while(__i < __fill && !__counter[__i].empty()) {
|
||||
__counter[__i].merge(__carry);
|
||||
__carry.swap(__counter[__i++]);
|
||||
}
|
||||
__carry.swap(__counter[__i]);
|
||||
if (__i == __fill) ++__fill;
|
||||
}
|
||||
|
||||
for (int __i = 1; __i < __fill; ++__i)
|
||||
__counter[__i].merge(__counter[__i-1]);
|
||||
swap(__counter[__fill-1]);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _Predicate>
|
||||
void list<_Tp, _Alloc>::
|
||||
remove_if(_Predicate __pred)
|
||||
{
|
||||
iterator __first = begin();
|
||||
iterator __last = end();
|
||||
while (__first != __last) {
|
||||
iterator __next = __first;
|
||||
++__next;
|
||||
if (__pred(*__first)) erase(__first);
|
||||
__first = __next;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _BinaryPredicate>
|
||||
void list<_Tp, _Alloc>::
|
||||
unique(_BinaryPredicate __binary_pred)
|
||||
{
|
||||
iterator __first = begin();
|
||||
iterator __last = end();
|
||||
if (__first == __last) return;
|
||||
iterator __next = __first;
|
||||
while (++__next != __last) {
|
||||
if (__binary_pred(*__first, *__next))
|
||||
erase(__next);
|
||||
else
|
||||
__first = __next;
|
||||
__next = __first;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _StrictWeakOrdering>
|
||||
void list<_Tp, _Alloc>::
|
||||
merge(list<_Tp, _Alloc>& __x, _StrictWeakOrdering __comp)
|
||||
{
|
||||
iterator __first1 = begin();
|
||||
iterator __last1 = end();
|
||||
iterator __first2 = __x.begin();
|
||||
iterator __last2 = __x.end();
|
||||
while (__first1 != __last1 && __first2 != __last2)
|
||||
if (__comp(*__first2, *__first1)) {
|
||||
iterator __next = __first2;
|
||||
_M_transfer(__first1, __first2, ++__next);
|
||||
__first2 = __next;
|
||||
}
|
||||
else
|
||||
++__first1;
|
||||
if (__first2 != __last2) _M_transfer(__last1, __first2, __last2);
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Alloc>
|
||||
template <typename _StrictWeakOrdering>
|
||||
void list<_Tp, _Alloc>::
|
||||
sort(_StrictWeakOrdering __comp)
|
||||
{
|
||||
// Do nothing if the list has length 0 or 1.
|
||||
if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
|
||||
list<_Tp, _Alloc> __carry;
|
||||
list<_Tp, _Alloc> __counter[64];
|
||||
int __fill = 0;
|
||||
while (!empty()) {
|
||||
__carry.splice(__carry.begin(), *this, begin());
|
||||
int __i = 0;
|
||||
while(__i < __fill && !__counter[__i].empty()) {
|
||||
__counter[__i].merge(__carry, __comp);
|
||||
__carry.swap(__counter[__i++]);
|
||||
}
|
||||
__carry.swap(__counter[__i]);
|
||||
if (__i == __fill) ++__fill;
|
||||
}
|
||||
|
||||
for (int __i = 1; __i < __fill; ++__i)
|
||||
__counter[__i].merge(__counter[__i-1], __comp);
|
||||
swap(__counter[__fill-1]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_LIST_H */
|
||||
|
||||
// vi:set ts=2 sw=2:
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
503
TBE/MinGW/include/c++/3.2.3/bits/stl_map.h
Normal file
503
TBE/MinGW/include/c++/3.2.3/bits/stl_map.h
Normal file
@@ -0,0 +1,503 @@
|
||||
// Map implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_map.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_MAP_H
|
||||
#define _CPP_BITS_STL_MAP_H 1
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
/**
|
||||
* @brief A standard container made up of pairs (see std::pair in <utility>)
|
||||
* which can be retrieved based on a key.
|
||||
*
|
||||
* This is an associative container. Values contained within it can be
|
||||
* quickly retrieved through a key element. Example: MyMap["First"] would
|
||||
* return the data associated with the key "First".
|
||||
*/
|
||||
template <class _Key, class _Tp, class _Compare = less<_Key>,
|
||||
class _Alloc = allocator<pair<const _Key, _Tp> > >
|
||||
class map
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept);
|
||||
|
||||
public:
|
||||
// typedefs:
|
||||
typedef _Key key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef pair<const _Key, _Tp> value_type;
|
||||
typedef _Compare key_compare;
|
||||
|
||||
class value_compare
|
||||
: public binary_function<value_type, value_type, bool> {
|
||||
friend class map<_Key,_Tp,_Compare,_Alloc>;
|
||||
protected :
|
||||
_Compare comp;
|
||||
value_compare(_Compare __c) : comp(__c) {}
|
||||
public:
|
||||
bool operator()(const value_type& __x, const value_type& __y) const {
|
||||
return comp(__x.first, __y.first);
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
typedef _Rb_tree<key_type, value_type,
|
||||
_Select1st<value_type>, key_compare, _Alloc> _Rep_type;
|
||||
_Rep_type _M_t; // red-black tree representing map
|
||||
public:
|
||||
typedef typename _Rep_type::pointer pointer;
|
||||
typedef typename _Rep_type::const_pointer const_pointer;
|
||||
typedef typename _Rep_type::reference reference;
|
||||
typedef typename _Rep_type::const_reference const_reference;
|
||||
typedef typename _Rep_type::iterator iterator;
|
||||
typedef typename _Rep_type::const_iterator const_iterator;
|
||||
typedef typename _Rep_type::reverse_iterator reverse_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename _Rep_type::size_type size_type;
|
||||
typedef typename _Rep_type::difference_type difference_type;
|
||||
typedef typename _Rep_type::allocator_type allocator_type;
|
||||
|
||||
// allocation/deallocation
|
||||
|
||||
map() : _M_t(_Compare(), allocator_type()) {}
|
||||
explicit map(const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
map(_InputIterator __first, _InputIterator __last)
|
||||
: _M_t(_Compare(), allocator_type())
|
||||
{ _M_t.insert_unique(__first, __last); }
|
||||
|
||||
template <class _InputIterator>
|
||||
map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
|
||||
map(const map<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
|
||||
|
||||
map<_Key,_Tp,_Compare,_Alloc>&
|
||||
operator=(const map<_Key, _Tp, _Compare, _Alloc>& __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 value_compare(_M_t.key_comp()); }
|
||||
allocator_type get_allocator() const { return _M_t.get_allocator(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write iterator that points to the first pair in the map.
|
||||
* Iteration is done in ascending order according to the keys.
|
||||
*/
|
||||
iterator begin() { return _M_t.begin(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) iterator that points to the first pair
|
||||
* in the map. Iteration is done in ascending order according to the keys.
|
||||
*/
|
||||
const_iterator begin() const { return _M_t.begin(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write iterator that points one past the last pair in the
|
||||
* map. Iteration is done in ascending order according to the keys.
|
||||
*/
|
||||
iterator end() { return _M_t.end(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) iterator that points one past the last
|
||||
* pair in the map. Iteration is done in ascending order according to the
|
||||
* keys.
|
||||
*/
|
||||
const_iterator end() const { return _M_t.end(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write reverse iterator that points to the last pair in
|
||||
* the map. Iteration is done in descending order according to the keys.
|
||||
*/
|
||||
reverse_iterator rbegin() { return _M_t.rbegin(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) reverse iterator that points to the last
|
||||
* pair in the map. Iteration is done in descending order according to
|
||||
* the keys.
|
||||
*/
|
||||
const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write reverse iterator that points to one before the
|
||||
* first pair in the map. Iteration is done in descending order according
|
||||
* to the keys.
|
||||
*/
|
||||
reverse_iterator rend() { return _M_t.rend(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) reverse iterator that points to one
|
||||
* before the first pair in the map. Iteration is done in descending order
|
||||
* according to the keys.
|
||||
*/
|
||||
const_reverse_iterator rend() const { return _M_t.rend(); }
|
||||
|
||||
/** Returns true if the map is empty. (Thus begin() would equal end().) */
|
||||
bool empty() const { return _M_t.empty(); }
|
||||
/** Returns the size of the map. */
|
||||
size_type size() const { return _M_t.size(); }
|
||||
/** Returns the maximum size of the map. */
|
||||
size_type max_size() const { return _M_t.max_size(); }
|
||||
|
||||
/**
|
||||
* @brief Subscript ( [] ) access to map data.
|
||||
* @param k The key for which data should be retrieved.
|
||||
*
|
||||
* Allows for easy lookup with the subscript ( [] ) operator. Returns the
|
||||
* data associated with the key specified in subscript. If the key does
|
||||
* not exist a pair with that key is created with a default value, which
|
||||
* is then returned.
|
||||
*/
|
||||
_Tp& operator[](const key_type& __k) {
|
||||
iterator __i = lower_bound(__k);
|
||||
// __i->first is greater than or equivalent to __k.
|
||||
if (__i == end() || key_comp()(__k, (*__i).first))
|
||||
__i = insert(__i, value_type(__k, _Tp()));
|
||||
return (*__i).second;
|
||||
}
|
||||
|
||||
void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
|
||||
|
||||
// insert/erase
|
||||
/**
|
||||
* @brief Attempts to insert a std::pair into the map.
|
||||
* @param x Pair to be inserted (see std::make_pair for easy creation of
|
||||
* pairs).
|
||||
* @return A pair of which the first element is an iterator that points
|
||||
* to the possibly inserted pair, a second element of type bool
|
||||
* to show if the pair was actually inserted.
|
||||
*
|
||||
* This function attempts to insert a (key, value) pair into the map. A
|
||||
* map relies on unique keys and thus a pair is only inserted if its first
|
||||
* element (the key) is not already present in the map.
|
||||
*/
|
||||
pair<iterator,bool> insert(const value_type& __x)
|
||||
{ return _M_t.insert_unique(__x); }
|
||||
|
||||
/**
|
||||
* @brief Attempts to insert a std::pair into the map.
|
||||
* @param position An iterator that serves as a hint as to where the
|
||||
* pair should be inserted.
|
||||
* @param x Pair to be inserted (see std::make_pair for easy creation of
|
||||
* pairs).
|
||||
* @return An iterator that points to the inserted (key,value) pair.
|
||||
*
|
||||
* This function is not concerned about whether the insertion took place
|
||||
* or not and thus does not return a boolean like the single-argument
|
||||
* insert() does. Note that the first parameter is only a hint and can
|
||||
* potentially improve the performance of the insertion process. A bad
|
||||
* hint would cause no gains in efficiency.
|
||||
*/
|
||||
iterator insert(iterator position, const value_type& __x)
|
||||
{ return _M_t.insert_unique(position, __x); }
|
||||
|
||||
/**
|
||||
* @brief A template function that attemps to insert elements from
|
||||
* another range (possibly another map).
|
||||
* @param first Iterator pointing to the start of the range to be inserted.
|
||||
* @param last Iterator pointing to the end of the range.
|
||||
*/
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last) {
|
||||
_M_t.insert_unique(__first, __last);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Erases an element from a map.
|
||||
* @param position An iterator pointing to the element to be erased.
|
||||
*
|
||||
* This function erases an element, pointed to by the given iterator, from
|
||||
* a map. Note that this function only erases the element, and that if
|
||||
* the element is itself a pointer, the pointed-to memory is not touched
|
||||
* in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
void erase(iterator __position) { _M_t.erase(__position); }
|
||||
|
||||
/**
|
||||
* @brief Erases an element according to the provided key.
|
||||
* @param x Key of element to be erased.
|
||||
* @return Doc me! (Number of elements that match key? Only makes sense
|
||||
* with multimap)
|
||||
*
|
||||
* This function erases an element, located by the given key, from a map.
|
||||
* Note that this function only erases the element, and that if
|
||||
* the element is itself a pointer, the pointed-to memory is not touched
|
||||
* in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
size_type erase(const key_type& __x) { return _M_t.erase(__x); }
|
||||
|
||||
/**
|
||||
* @brief Erases a [first,last) range of elements from a map.
|
||||
* @param first Iterator pointing to the start of the range to be erased.
|
||||
* @param last Iterator pointing to the end of the range to be erased.
|
||||
*
|
||||
* This function erases a sequence of elements from a map.
|
||||
* Note that this function only erases the element, and that if
|
||||
* the element is itself a pointer, the pointed-to memory is not touched
|
||||
* in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
void erase(iterator __first, iterator __last)
|
||||
{ _M_t.erase(__first, __last); }
|
||||
|
||||
/** Erases all elements in a map. Note that this function only erases
|
||||
* the elements, and that if the elements themselves are pointers, the
|
||||
* pointed-to memory is not touched in any way. Managing the pointer is
|
||||
* the user's responsibilty.
|
||||
*/
|
||||
void clear() { _M_t.clear(); }
|
||||
|
||||
// map operations:
|
||||
|
||||
/**
|
||||
* @brief Tries to locate an element in a map.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to sought-after element, or end() if not
|
||||
* found.
|
||||
*
|
||||
* This function takes a key and tries to locate the element with which
|
||||
* the key matches. If successful the function returns an iterator
|
||||
* pointing to the sought after pair. If unsuccessful it returns the
|
||||
* one past the end ( end() ) iterator.
|
||||
*/
|
||||
iterator find(const key_type& __x) { return _M_t.find(__x); }
|
||||
|
||||
/**
|
||||
* @brief Tries to locate an element in a map.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to sought-after
|
||||
* element, or end() if not found.
|
||||
*
|
||||
* This function takes a key and tries to locate the element with which
|
||||
* the key matches. If successful the function returns a constant iterator
|
||||
* pointing to the sought after pair. If unsuccessful it returns the
|
||||
* one past the end ( end() ) iterator.
|
||||
*/
|
||||
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the number of elements with given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Number of elements with specified key.
|
||||
*
|
||||
* This function only makes sense for multimaps.
|
||||
*/
|
||||
size_type count(const key_type& __x) const {
|
||||
return _M_t.find(__x) == _M_t.end() ? 0 : 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds the beginning of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to first element matching given key, or
|
||||
* end() if not found.
|
||||
*
|
||||
* This function is useful only with std::multimap. It returns the first
|
||||
* element of a subsequence of elements that matches the given key. If
|
||||
* unsuccessful it returns an iterator pointing to the first element that
|
||||
* has a greater value than given key or end() if no such element exists.
|
||||
*/
|
||||
iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the beginning of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to first element
|
||||
* matching given key, or end() if not found.
|
||||
*
|
||||
* This function is useful only with std::multimap. It returns the first
|
||||
* element of a subsequence of elements that matches the given key. If
|
||||
* unsuccessful the iterator will point to the next greatest element or,
|
||||
* if no such greater element exists, to end().
|
||||
*/
|
||||
const_iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds the end of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to last element matching given key.
|
||||
*
|
||||
* This function only makes sense with multimaps.
|
||||
*/
|
||||
iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the end of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to last element matching
|
||||
* given key.
|
||||
*
|
||||
* This function only makes sense with multimaps.
|
||||
*/
|
||||
const_iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds a subsequence matching given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Pair of iterators that possibly points to the subsequence
|
||||
* matching given key.
|
||||
*
|
||||
* This function improves on lower_bound() and upper_bound() by giving a more
|
||||
* elegant and efficient solution. It returns a pair of which the first
|
||||
* element possibly points to the first element matching the given key
|
||||
* and the second element possibly points to the last element matching the
|
||||
* given key. If unsuccessful the first element of the returned pair will
|
||||
* contain an iterator pointing to the next greatest element or, if no such
|
||||
* greater element exists, to end().
|
||||
*
|
||||
* This function only makes sense for multimaps.
|
||||
*/
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds a subsequence matching given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Pair of read-only (constant) iterators that possibly points to
|
||||
* the subsequence matching given key.
|
||||
*
|
||||
* This function improves on lower_bound() and upper_bound() by giving a more
|
||||
* elegant and efficient solution. It returns a pair of which the first
|
||||
* element possibly points to the first element matching the given key
|
||||
* and the second element possibly points to the last element matching the
|
||||
* given key. If unsuccessful the first element of the returned pair will
|
||||
* contain an iterator pointing to the next greatest element or, if no such
|
||||
* a greater element exists, to end().
|
||||
*
|
||||
* This function only makes sense for multimaps.
|
||||
*/
|
||||
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
|
||||
template <class _K1, class _T1, class _C1, class _A1>
|
||||
friend bool operator== (const map<_K1, _T1, _C1, _A1>&,
|
||||
const map<_K1, _T1, _C1, _A1>&);
|
||||
template <class _K1, class _T1, class _C1, class _A1>
|
||||
friend bool operator< (const map<_K1, _T1, _C1, _A1>&,
|
||||
const map<_K1, _T1, _C1, _A1>&);
|
||||
};
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t == __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t < __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
map<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_MAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
491
TBE/MinGW/include/c++/3.2.3/bits/stl_multimap.h
Normal file
491
TBE/MinGW/include/c++/3.2.3/bits/stl_multimap.h
Normal file
@@ -0,0 +1,491 @@
|
||||
// Multimap implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_multimap.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_MULTIMAP_H
|
||||
#define __GLIBCPP_INTERNAL_MULTIMAP_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Forward declaration of operators < and ==, needed for friend declaration.
|
||||
template <class _Key, class _Tp,
|
||||
class _Compare = less<_Key>,
|
||||
class _Alloc = allocator<pair<const _Key, _Tp> > >
|
||||
class multimap;
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y);
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y);
|
||||
|
||||
/**
|
||||
* @brief A standard container made up of pairs (see std::pair in <utility>)
|
||||
* which can be retrieved based on a key.
|
||||
*
|
||||
* This is an associative container. Values contained within it can be
|
||||
* quickly retrieved through a key element. In contrast with a map a
|
||||
* multimap can have multiple duplicate keys.
|
||||
*/
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
class multimap
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept);
|
||||
|
||||
public:
|
||||
|
||||
// typedefs:
|
||||
|
||||
typedef _Key key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef pair<const _Key, _Tp> value_type;
|
||||
typedef _Compare key_compare;
|
||||
|
||||
class value_compare : public binary_function<value_type, value_type, bool> {
|
||||
friend class multimap<_Key,_Tp,_Compare,_Alloc>;
|
||||
protected:
|
||||
_Compare comp;
|
||||
value_compare(_Compare __c) : comp(__c) {}
|
||||
public:
|
||||
bool operator()(const value_type& __x, const value_type& __y) const {
|
||||
return comp(__x.first, __y.first);
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
typedef _Rb_tree<key_type, value_type,
|
||||
_Select1st<value_type>, key_compare, _Alloc> _Rep_type;
|
||||
_Rep_type _M_t; // red-black tree representing multimap
|
||||
public:
|
||||
typedef typename _Rep_type::pointer pointer;
|
||||
typedef typename _Rep_type::const_pointer const_pointer;
|
||||
typedef typename _Rep_type::reference reference;
|
||||
typedef typename _Rep_type::const_reference const_reference;
|
||||
typedef typename _Rep_type::iterator iterator;
|
||||
typedef typename _Rep_type::const_iterator const_iterator;
|
||||
typedef typename _Rep_type::reverse_iterator reverse_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename _Rep_type::size_type size_type;
|
||||
typedef typename _Rep_type::difference_type difference_type;
|
||||
typedef typename _Rep_type::allocator_type allocator_type;
|
||||
|
||||
// allocation/deallocation
|
||||
|
||||
multimap() : _M_t(_Compare(), allocator_type()) { }
|
||||
explicit multimap(const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) { }
|
||||
|
||||
template <class _InputIterator>
|
||||
multimap(_InputIterator __first, _InputIterator __last)
|
||||
: _M_t(_Compare(), allocator_type())
|
||||
{ _M_t.insert_equal(__first, __last); }
|
||||
|
||||
template <class _InputIterator>
|
||||
multimap(_InputIterator __first, _InputIterator __last,
|
||||
const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
|
||||
multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { }
|
||||
|
||||
multimap<_Key,_Tp,_Compare,_Alloc>&
|
||||
operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __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 value_compare(_M_t.key_comp()); }
|
||||
allocator_type get_allocator() const { return _M_t.get_allocator(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write iterator that points to the first pair in the
|
||||
* multimap. Iteration is done in ascending order according to the keys.
|
||||
*/
|
||||
iterator begin() { return _M_t.begin(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) iterator that points to the first pair
|
||||
* in the multimap. Iteration is done in ascending order according to the
|
||||
* keys.
|
||||
*/
|
||||
const_iterator begin() const { return _M_t.begin(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write iterator that points one past the last pair in the
|
||||
* multimap. Iteration is done in ascending order according to the keys.
|
||||
*/
|
||||
iterator end() { return _M_t.end(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) iterator that points one past the last
|
||||
* pair in the multimap. Iteration is done in ascending order according
|
||||
* to the keys.
|
||||
*/
|
||||
const_iterator end() const { return _M_t.end(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write reverse iterator that points to the last pair in
|
||||
* the multimap. Iteration is done in descending order according to the
|
||||
* keys.
|
||||
*/
|
||||
reverse_iterator rbegin() { return _M_t.rbegin(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) reverse iterator that points to the last
|
||||
* pair in the multimap. Iteration is done in descending order according
|
||||
* to the keys.
|
||||
*/
|
||||
const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
|
||||
|
||||
/**
|
||||
* Returns a read/write reverse iterator that points to one before the
|
||||
* first pair in the multimap. Iteration is done in descending order
|
||||
* according to the keys.
|
||||
*/
|
||||
reverse_iterator rend() { return _M_t.rend(); }
|
||||
|
||||
/**
|
||||
* Returns a read-only (constant) reverse iterator that points to one
|
||||
* before the first pair in the multimap. Iteration is done in descending
|
||||
* order according to the keys.
|
||||
*/
|
||||
const_reverse_iterator rend() const { return _M_t.rend(); }
|
||||
|
||||
/** Returns true if the map is empty. (Thus begin() would equal end().) */
|
||||
bool empty() const { return _M_t.empty(); }
|
||||
|
||||
/** Returns the size of the map. */
|
||||
size_type size() const { return _M_t.size(); }
|
||||
|
||||
/** Returns the maximum size of the map. */
|
||||
size_type max_size() const { return _M_t.max_size(); }
|
||||
|
||||
void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
|
||||
|
||||
// insert/erase
|
||||
/**
|
||||
* @brief Inserts a std::pair into the multimap.
|
||||
* @param x Pair to be inserted (see std::make_pair for easy creation of
|
||||
* pairs).
|
||||
* @return An iterator that points to the inserted (key,value) pair.
|
||||
*
|
||||
* This function inserts a (key, value) pair into the multimap. Contrary
|
||||
* to a std::map the multimap does not rely on unique keys and thus a
|
||||
* multiple pairs with the same key can be inserted.
|
||||
*/
|
||||
iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
|
||||
|
||||
/**
|
||||
* @brief Inserts a std::pair into the multimap.
|
||||
* @param position An iterator that serves as a hint as to where the
|
||||
* pair should be inserted.
|
||||
* @param x Pair to be inserted (see std::make_pair for easy creation of
|
||||
* pairs).
|
||||
* @return An iterator that points to the inserted (key,value) pair.
|
||||
*
|
||||
* This function inserts a (key, value) pair into the multimap. Contrary
|
||||
* to a std::map the multimap does not rely on unique keys and thus a
|
||||
* multiple pairs with the same key can be inserted.
|
||||
* Note that the first parameter is only a hint and can potentially
|
||||
* improve the performance of the insertion process. A bad hint would
|
||||
* cause no gains in efficiency.
|
||||
*/
|
||||
iterator insert(iterator __position, const value_type& __x) {
|
||||
return _M_t.insert_equal(__position, __x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief A template function that attemps to insert elements from
|
||||
* another range (possibly another multimap or standard container).
|
||||
* @param first Iterator pointing to the start of the range to be
|
||||
* inserted.
|
||||
* @param last Iterator pointing to the end of the range to be inserted.
|
||||
*/
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last) {
|
||||
_M_t.insert_equal(__first, __last);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Erases an element from a multimap.
|
||||
* @param position An iterator pointing to the element to be erased.
|
||||
*
|
||||
* This function erases an element, pointed to by the given iterator, from
|
||||
* a mutlimap. Note that this function only erases the element, and that
|
||||
* if the element is itself a pointer, the pointed-to memory is not
|
||||
* touched in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
void erase(iterator __position) { _M_t.erase(__position); }
|
||||
|
||||
/**
|
||||
* @brief Erases an element according to the provided key.
|
||||
* @param x Key of element to be erased.
|
||||
* @return Doc me! (Number of elements erased?)
|
||||
*
|
||||
* This function erases all elements, located by the given key, from a
|
||||
* multimap.
|
||||
* Note that this function only erases the element, and that if
|
||||
* the element is itself a pointer, the pointed-to memory is not touched
|
||||
* in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
size_type erase(const key_type& __x) { return _M_t.erase(__x); }
|
||||
|
||||
/**
|
||||
* @brief Erases a [first,last) range of elements from a multimap.
|
||||
* @param first Iterator pointing to the start of the range to be erased.
|
||||
* @param last Iterator pointing to the end of the range to be erased.
|
||||
*
|
||||
* This function erases a sequence of elements from a multimap.
|
||||
* Note that this function only erases the elements, and that if
|
||||
* the elements themselves are pointers, the pointed-to memory is not
|
||||
* touched in any way. Managing the pointer is the user's responsibilty.
|
||||
*/
|
||||
void erase(iterator __first, iterator __last)
|
||||
{ _M_t.erase(__first, __last); }
|
||||
|
||||
/** Erases all elements in a multimap. Note that this function only erases
|
||||
* the elements, and that if the elements themselves are pointers, the
|
||||
* pointed-to memory is not touched in any way. Managing the pointer is
|
||||
* the user's responsibilty.
|
||||
*/
|
||||
void clear() { _M_t.clear(); }
|
||||
|
||||
// multimap operations:
|
||||
|
||||
/**
|
||||
* @brief Tries to locate an element in a multimap.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to sought-after (first matching?) element,
|
||||
* or end() if not found.
|
||||
*
|
||||
* This function takes a key and tries to locate the element with which
|
||||
* the key matches. If successful the function returns an iterator
|
||||
* pointing to the sought after pair. If unsuccessful it returns the
|
||||
* one past the end ( end() ) iterator.
|
||||
*/
|
||||
iterator find(const key_type& __x) { return _M_t.find(__x); }
|
||||
|
||||
/**
|
||||
* @brief Tries to locate an element in a multimap.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to sought-after (first
|
||||
* matching?) element, or end() if not found.
|
||||
*
|
||||
* This function takes a key and tries to locate the element with which
|
||||
* the key matches. If successful the function returns a constant iterator
|
||||
* pointing to the sought after pair. If unsuccessful it returns the
|
||||
* one past the end ( end() ) iterator.
|
||||
*/
|
||||
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the number of elements with given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Number of elements with specified key.
|
||||
*/
|
||||
size_type count(const key_type& __x) const { return _M_t.count(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the beginning of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to first element matching given key, or
|
||||
* end() if not found.
|
||||
*
|
||||
* This function returns the first element of a subsequence of elements
|
||||
* that matches the given key. If unsuccessful it returns an iterator
|
||||
* pointing to the first element that has a greater value than given key
|
||||
* or end() if no such element exists.
|
||||
*/
|
||||
iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the beginning of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to first element
|
||||
* matching given key, or end() if not found.
|
||||
*
|
||||
* This function returns the first element of a subsequence of elements
|
||||
* that matches the given key. If unsuccessful the iterator will point
|
||||
* to the next greatest element or, if no such greater element exists, to
|
||||
* end().
|
||||
*/
|
||||
const_iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds the end of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Iterator pointing to last element matching given key.
|
||||
*/
|
||||
iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
|
||||
|
||||
/**
|
||||
* @brief Finds the end of a subsequence matching given key.
|
||||
* @param x Key of (key, value) pair to be located.
|
||||
* @return Read-only (constant) iterator pointing to last element matching
|
||||
* given key.
|
||||
*/
|
||||
const_iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds a subsequence matching given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Pair of iterators that possibly points to the subsequence
|
||||
* matching given key.
|
||||
*
|
||||
* This function improves on lower_bound() and upper_bound() by giving a more
|
||||
* elegant and efficient solution. It returns a pair of which the first
|
||||
* element possibly points to the first element matching the given key
|
||||
* and the second element possibly points to the last element matching the
|
||||
* given key. If unsuccessful the first element of the returned pair will
|
||||
* contain an iterator pointing to the next greatest element or, if no such
|
||||
* greater element exists, to end().
|
||||
*/
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Finds a subsequence matching given key.
|
||||
* @param x Key of (key, value) pairs to be located.
|
||||
* @return Pair of read-only (constant) iterators that possibly points to
|
||||
* the subsequence matching given key.
|
||||
*
|
||||
* This function improves on lower_bound() and upper_bound() by giving a more
|
||||
* elegant and efficient solution. It returns a pair of which the first
|
||||
* element possibly points to the first element matching the given key
|
||||
* and the second element possibly points to the last element matching the
|
||||
* given key. If unsuccessful the first element of the returned pair will
|
||||
* contain an iterator pointing to the next greatest element or, if no such
|
||||
* a greater element exists, to end().
|
||||
*/
|
||||
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
|
||||
template <class _K1, class _T1, class _C1, class _A1>
|
||||
friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&,
|
||||
const multimap<_K1, _T1, _C1, _A1>&);
|
||||
template <class _K1, class _T1, class _C1, class _A1>
|
||||
friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&,
|
||||
const multimap<_K1, _T1, _C1, _A1>&);
|
||||
};
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t == __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t < __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Alloc>
|
||||
inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
|
||||
multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_MULTIMAP_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
277
TBE/MinGW/include/c++/3.2.3/bits/stl_multiset.h
Normal file
277
TBE/MinGW/include/c++/3.2.3/bits/stl_multiset.h
Normal file
@@ -0,0 +1,277 @@
|
||||
// Multiset implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_multiset.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_MULTISET_H
|
||||
#define __GLIBCPP_INTERNAL_MULTISET_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// Forward declaration of operators < and ==, needed for friend declaration.
|
||||
|
||||
template <class _Key, class _Compare = less<_Key>,
|
||||
class _Alloc = allocator<_Key> >
|
||||
class multiset;
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y);
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y);
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
class multiset
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Key, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept);
|
||||
|
||||
public:
|
||||
|
||||
// typedefs:
|
||||
|
||||
typedef _Key key_type;
|
||||
typedef _Key value_type;
|
||||
typedef _Compare key_compare;
|
||||
typedef _Compare value_compare;
|
||||
private:
|
||||
typedef _Rb_tree<key_type, value_type,
|
||||
_Identity<value_type>, key_compare, _Alloc> _Rep_type;
|
||||
_Rep_type _M_t; // red-black tree representing multiset
|
||||
public:
|
||||
typedef typename _Rep_type::const_pointer pointer;
|
||||
typedef typename _Rep_type::const_pointer const_pointer;
|
||||
typedef typename _Rep_type::const_reference reference;
|
||||
typedef typename _Rep_type::const_reference const_reference;
|
||||
typedef typename _Rep_type::const_iterator iterator;
|
||||
typedef typename _Rep_type::const_iterator const_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename _Rep_type::size_type size_type;
|
||||
typedef typename _Rep_type::difference_type difference_type;
|
||||
typedef typename _Rep_type::allocator_type allocator_type;
|
||||
|
||||
// allocation/deallocation
|
||||
|
||||
multiset() : _M_t(_Compare(), allocator_type()) {}
|
||||
explicit multiset(const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
multiset(_InputIterator __first, _InputIterator __last)
|
||||
: _M_t(_Compare(), allocator_type())
|
||||
{ _M_t.insert_equal(__first, __last); }
|
||||
|
||||
template <class _InputIterator>
|
||||
multiset(_InputIterator __first, _InputIterator __last,
|
||||
const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
|
||||
|
||||
multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
|
||||
|
||||
multiset<_Key,_Compare,_Alloc>&
|
||||
operator=(const multiset<_Key,_Compare,_Alloc>& __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 _M_t.get_allocator(); }
|
||||
|
||||
iterator begin() const { return _M_t.begin(); }
|
||||
iterator end() const { return _M_t.end(); }
|
||||
reverse_iterator rbegin() const { return _M_t.rbegin(); }
|
||||
reverse_iterator rend() const { return _M_t.rend(); }
|
||||
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(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
|
||||
|
||||
// insert/erase
|
||||
iterator insert(const value_type& __x) {
|
||||
return _M_t.insert_equal(__x);
|
||||
}
|
||||
iterator insert(iterator __position, const value_type& __x) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
return _M_t.insert_equal((_Rep_iterator&)__position, __x);
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last) {
|
||||
_M_t.insert_equal(__first, __last);
|
||||
}
|
||||
void erase(iterator __position) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
_M_t.erase((_Rep_iterator&)__position);
|
||||
}
|
||||
size_type erase(const key_type& __x) {
|
||||
return _M_t.erase(__x);
|
||||
}
|
||||
void erase(iterator __first, iterator __last) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
|
||||
}
|
||||
void clear() { _M_t.clear(); }
|
||||
|
||||
// multiset operations:
|
||||
|
||||
size_type count(const key_type& __x) const { return _M_t.count(__x); }
|
||||
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//214. set::find() missing const overload
|
||||
iterator find(const key_type& __x) { return _M_t.find(__x); }
|
||||
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
iterator lower_bound(const key_type& __x) {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
const_iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
iterator upper_bound(const key_type& __x) {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
const_iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
#else
|
||||
iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class _K1, class _C1, class _A1>
|
||||
friend bool operator== (const multiset<_K1,_C1,_A1>&,
|
||||
const multiset<_K1,_C1,_A1>&);
|
||||
template <class _K1, class _C1, class _A1>
|
||||
friend bool operator< (const multiset<_K1,_C1,_A1>&,
|
||||
const multiset<_K1,_C1,_A1>&);
|
||||
};
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t == __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t < __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator!=(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator>(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<=(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator>=(const multiset<_Key,_Compare,_Alloc>& __x,
|
||||
const multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline void swap(multiset<_Key,_Compare,_Alloc>& __x,
|
||||
multiset<_Key,_Compare,_Alloc>& __y) {
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_MULTISET_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
215
TBE/MinGW/include/c++/3.2.3/bits/stl_numeric.h
Normal file
215
TBE/MinGW/include/c++/3.2.3/bits/stl_numeric.h
Normal file
@@ -0,0 +1,215 @@
|
||||
// Numeric functions implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_numeric.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_NUMERIC_H
|
||||
#define _CPP_BITS_STL_NUMERIC_H 1
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
template<typename _InputIterator, typename _Tp>
|
||||
_Tp
|
||||
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
|
||||
for ( ; __first != __last; ++__first)
|
||||
__init = __init + *__first;
|
||||
return __init;
|
||||
}
|
||||
|
||||
template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
|
||||
_Tp
|
||||
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
|
||||
_BinaryOperation __binary_op)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
|
||||
for ( ; __first != __last; ++__first)
|
||||
__init = __binary_op(__init, *__first);
|
||||
return __init;
|
||||
}
|
||||
|
||||
template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
|
||||
_Tp
|
||||
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
|
||||
_InputIterator2 __first2, _Tp __init)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
|
||||
|
||||
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||||
__init = __init + (*__first1 * *__first2);
|
||||
return __init;
|
||||
}
|
||||
|
||||
template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
|
||||
typename _BinaryOperation1, typename _BinaryOperation2>
|
||||
_Tp
|
||||
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
|
||||
_InputIterator2 __first2, _Tp __init,
|
||||
_BinaryOperation1 __binary_op1,
|
||||
_BinaryOperation2 __binary_op2)
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>)
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>)
|
||||
|
||||
for ( ; __first1 != __last1; ++__first1, ++__first2)
|
||||
__init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
|
||||
return __init;
|
||||
}
|
||||
|
||||
template<typename _InputIterator, typename _OutputIterator>
|
||||
_OutputIterator
|
||||
partial_sum(_InputIterator __first, _InputIterator __last,
|
||||
_OutputIterator __result)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, _ValueType>)
|
||||
|
||||
if (__first == __last) return __result;
|
||||
*__result = *__first;
|
||||
_ValueType __value = *__first;
|
||||
while (++__first != __last) {
|
||||
__value = __value + *__first;
|
||||
*++__result = __value;
|
||||
}
|
||||
return ++__result;
|
||||
}
|
||||
|
||||
template<typename _InputIterator, typename _OutputIterator, typename _BinaryOperation>
|
||||
_OutputIterator
|
||||
partial_sum(_InputIterator __first, _InputIterator __last,
|
||||
_OutputIterator __result, _BinaryOperation __binary_op)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, _ValueType>)
|
||||
|
||||
if (__first == __last) return __result;
|
||||
*__result = *__first;
|
||||
_ValueType __value = *__first;
|
||||
while (++__first != __last) {
|
||||
__value = __binary_op(__value, *__first);
|
||||
*++__result = __value;
|
||||
}
|
||||
return ++__result;
|
||||
}
|
||||
|
||||
template<typename _InputIterator, typename _OutputIterator>
|
||||
_OutputIterator
|
||||
adjacent_difference(_InputIterator __first,
|
||||
_InputIterator __last, _OutputIterator __result)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, _ValueType>)
|
||||
|
||||
if (__first == __last) return __result;
|
||||
*__result = *__first;
|
||||
_ValueType __value = *__first;
|
||||
while (++__first != __last) {
|
||||
_ValueType __tmp = *__first;
|
||||
*++__result = __tmp - __value;
|
||||
__value = __tmp;
|
||||
}
|
||||
return ++__result;
|
||||
}
|
||||
|
||||
template<typename _InputIterator, typename _OutputIterator, typename _BinaryOperation>
|
||||
_OutputIterator
|
||||
adjacent_difference(_InputIterator __first, _InputIterator __last,
|
||||
_OutputIterator __result, _BinaryOperation __binary_op)
|
||||
{
|
||||
typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
|
||||
|
||||
// concept requirements
|
||||
__glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
|
||||
__glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, _ValueType>)
|
||||
|
||||
if (__first == __last) return __result;
|
||||
*__result = *__first;
|
||||
_ValueType __value = *__first;
|
||||
while (++__first != __last) {
|
||||
_ValueType __tmp = *__first;
|
||||
*++__result = __binary_op(__tmp, __value);
|
||||
__value = __tmp;
|
||||
}
|
||||
return ++__result;
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_NUMERIC_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
157
TBE/MinGW/include/c++/3.2.3/bits/stl_pair.h
Normal file
157
TBE/MinGW/include/c++/3.2.3/bits/stl_pair.h
Normal file
@@ -0,0 +1,157 @@
|
||||
// Pair implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_pair.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_PAIR_H
|
||||
#define __GLIBCPP_INTERNAL_PAIR_H
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
/// 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
|
||||
#ifdef _GLIBCPP_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() {}
|
||||
#else
|
||||
pair() : first(_T1()), second(_T2()) {}
|
||||
#endif
|
||||
/** Two objects may be passed to a @c pair constructor to be copied. */
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief A convenience wrapper for creating a pair from two objects.
|
||||
* @param x The first object.
|
||||
* @param y The second object.
|
||||
* @return A newly-constructed pair<> object of the appropriate type.
|
||||
*
|
||||
* 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>
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//181. make_pair() unintended behavior
|
||||
inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y)
|
||||
#else
|
||||
inline pair<_T1, _T2> make_pair(const _T1& __x, const _T2& __y)
|
||||
#endif
|
||||
{
|
||||
return pair<_T1, _T2>(__x, __y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_PAIR_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
60
TBE/MinGW/include/c++/3.2.3/bits/stl_pthread_alloc.h
Normal file
60
TBE/MinGW/include/c++/3.2.3/bits/stl_pthread_alloc.h
Normal file
@@ -0,0 +1,60 @@
|
||||
// Wrapper of pthread allocation header -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1996-1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_pthread_alloc.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_PTHREAD_ALLOC_H
|
||||
#define _CPP_BITS_STL_PTHREAD_ALLOC_H 1
|
||||
|
||||
#include <bits/pthread_allocimpl.h>
|
||||
|
||||
using std::_Pthread_alloc_template;
|
||||
using std::pthread_alloc;
|
||||
|
||||
#endif /* _CPP_BITS_STL_PTHREAD_ALLOC_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
244
TBE/MinGW/include/c++/3.2.3/bits/stl_queue.h
Normal file
244
TBE/MinGW/include/c++/3.2.3/bits/stl_queue.h
Normal file
@@ -0,0 +1,244 @@
|
||||
// Queue implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_queue.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_QUEUE_H
|
||||
#define __GLIBCPP_INTERNAL_QUEUE_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// Forward declarations of operators < and ==, needed for friend declaration.
|
||||
|
||||
template <class _Tp,
|
||||
class _Sequence = deque<_Tp> >
|
||||
class queue;
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
|
||||
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
class queue
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept)
|
||||
__glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept)
|
||||
typedef typename _Sequence::value_type _Sequence_value_type;
|
||||
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
|
||||
|
||||
template <class _Tp1, class _Seq1>
|
||||
friend bool operator== (const queue<_Tp1, _Seq1>&,
|
||||
const queue<_Tp1, _Seq1>&);
|
||||
template <class _Tp1, class _Seq1>
|
||||
friend bool operator< (const queue<_Tp1, _Seq1>&,
|
||||
const queue<_Tp1, _Seq1>&);
|
||||
public:
|
||||
typedef typename _Sequence::value_type value_type;
|
||||
typedef typename _Sequence::size_type size_type;
|
||||
typedef _Sequence container_type;
|
||||
|
||||
typedef typename _Sequence::reference reference;
|
||||
typedef typename _Sequence::const_reference const_reference;
|
||||
protected:
|
||||
_Sequence c;
|
||||
public:
|
||||
explicit queue(const _Sequence& __c = _Sequence()) : c(__c) {}
|
||||
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
reference front() { return c.front(); }
|
||||
const_reference front() const { return c.front(); }
|
||||
reference back() { return c.back(); }
|
||||
const_reference back() const { return c.back(); }
|
||||
void push(const value_type& __x) { c.push_back(__x); }
|
||||
void pop() { c.pop_front(); }
|
||||
};
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return __x.c == __y.c;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return __x.c < __y.c;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
bool
|
||||
operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
|
||||
{
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Tp,
|
||||
class _Sequence = vector<_Tp>,
|
||||
class _Compare = less<typename _Sequence::value_type> >
|
||||
class priority_queue
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires(_Sequence, _SequenceConcept)
|
||||
__glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept)
|
||||
typedef typename _Sequence::value_type _Sequence_value_type;
|
||||
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
|
||||
__glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept);
|
||||
|
||||
public:
|
||||
typedef typename _Sequence::value_type value_type;
|
||||
typedef typename _Sequence::size_type size_type;
|
||||
typedef _Sequence container_type;
|
||||
|
||||
typedef typename _Sequence::reference reference;
|
||||
typedef typename _Sequence::const_reference const_reference;
|
||||
protected:
|
||||
_Sequence c;
|
||||
_Compare comp;
|
||||
public:
|
||||
explicit priority_queue(const _Compare& __x = _Compare(),
|
||||
const _Sequence& __s = _Sequence())
|
||||
: c(__s), comp(__x)
|
||||
{ make_heap(c.begin(), c.end(), comp); }
|
||||
|
||||
template <class _InputIterator>
|
||||
priority_queue(_InputIterator __first, _InputIterator __last,
|
||||
const _Compare& __x = _Compare(),
|
||||
const _Sequence& __s = _Sequence())
|
||||
: c(__s), comp(__x)
|
||||
{
|
||||
c.insert(c.end(), __first, __last);
|
||||
make_heap(c.begin(), c.end(), comp);
|
||||
}
|
||||
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
const_reference top() const { return c.front(); }
|
||||
|
||||
void
|
||||
push(const value_type& __x)
|
||||
{
|
||||
try
|
||||
{
|
||||
c.push_back(__x);
|
||||
push_heap(c.begin(), c.end(), comp);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
c.clear();
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
pop()
|
||||
{
|
||||
try
|
||||
{
|
||||
pop_heap(c.begin(), c.end(), comp);
|
||||
c.pop_back();
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
c.clear();
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// no equality is provided
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_QUEUE_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
112
TBE/MinGW/include/c++/3.2.3/bits/stl_raw_storage_iter.h
Normal file
112
TBE/MinGW/include/c++/3.2.3/bits/stl_raw_storage_iter.h
Normal file
@@ -0,0 +1,112 @@
|
||||
// -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_raw_storage_iter.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H
|
||||
#define _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H 1
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* This iterator class lets algorithms store their results into
|
||||
* uninitialized memory.
|
||||
*/
|
||||
template <class _ForwardIterator, class _Tp>
|
||||
class raw_storage_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
protected:
|
||||
_ForwardIterator _M_iter;
|
||||
|
||||
public:
|
||||
explicit
|
||||
raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
|
||||
|
||||
raw_storage_iterator&
|
||||
operator*() { return *this; }
|
||||
|
||||
raw_storage_iterator&
|
||||
operator=(const _Tp& __element)
|
||||
{
|
||||
_Construct(&*_M_iter, __element);
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_storage_iterator<_ForwardIterator, _Tp>&
|
||||
operator++()
|
||||
{
|
||||
++_M_iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_storage_iterator<_ForwardIterator, _Tp>
|
||||
operator++(int)
|
||||
{
|
||||
raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
|
||||
++_M_iter;
|
||||
return __tmp;
|
||||
}
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
141
TBE/MinGW/include/c++/3.2.3/bits/stl_relops.h
Normal file
141
TBE/MinGW/include/c++/3.2.3/bits/stl_relops.h
Normal file
@@ -0,0 +1,141 @@
|
||||
// std::rel_ops implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
/** @file stl_relops.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*
|
||||
* @if maint
|
||||
* Inclusion of this file has been removed from
|
||||
* all of the other STL headers for safety reasons, except std_utility.h.
|
||||
* For more information, see the thread of about twenty messages starting
|
||||
* with http://gcc.gnu.org/ml/libstdc++/2001-01/msg00223.html , or the
|
||||
* FAQ at http://gcc.gnu.org/onlinedocs/libstdc++/faq/index.html#4_4 .
|
||||
*
|
||||
* Short summary: the rel_ops operators should be avoided for the present.
|
||||
* @endif
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_RELOPS_H
|
||||
#define _CPP_BITS_STL_RELOPS_H 1
|
||||
|
||||
namespace std
|
||||
{
|
||||
namespace rel_ops
|
||||
{
|
||||
/** @namespace std::rel_ops
|
||||
* @brief The generated relational operators are sequestered here.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Defines @c != for arbitrary types, in terms of @c ==.
|
||||
* @param x A thing.
|
||||
* @param y Another thing.
|
||||
* @return x != y
|
||||
*
|
||||
* This function uses @c == to determine its result.
|
||||
*/
|
||||
template <class _Tp>
|
||||
inline bool operator!=(const _Tp& __x, const _Tp& __y) {
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Defines @c > for arbitrary types, in terms of @c <.
|
||||
* @param x A thing.
|
||||
* @param y Another thing.
|
||||
* @return x > y
|
||||
*
|
||||
* This function uses @c < to determine its result.
|
||||
*/
|
||||
template <class _Tp>
|
||||
inline bool operator>(const _Tp& __x, const _Tp& __y) {
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Defines @c <= for arbitrary types, in terms of @c <.
|
||||
* @param x A thing.
|
||||
* @param y Another thing.
|
||||
* @return x <= y
|
||||
*
|
||||
* This function uses @c < to determine its result.
|
||||
*/
|
||||
template <class _Tp>
|
||||
inline bool operator<=(const _Tp& __x, const _Tp& __y) {
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Defines @c >= for arbitrary types, in terms of @c <.
|
||||
* @param x A thing.
|
||||
* @param y Another thing.
|
||||
* @return x >= y
|
||||
*
|
||||
* This function uses @c < to determine its result.
|
||||
*/
|
||||
template <class _Tp>
|
||||
inline bool operator>=(const _Tp& __x, const _Tp& __y) {
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
} // namespace rel_ops
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_RELOPS_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
274
TBE/MinGW/include/c++/3.2.3/bits/stl_set.h
Normal file
274
TBE/MinGW/include/c++/3.2.3/bits/stl_set.h
Normal file
@@ -0,0 +1,274 @@
|
||||
// Set implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_set.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_SET_H
|
||||
#define __GLIBCPP_INTERNAL_SET_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// Forward declarations of operators < and ==, needed for friend declaration.
|
||||
|
||||
template <class _Key, class _Compare = less<_Key>,
|
||||
class _Alloc = allocator<_Key> >
|
||||
class set;
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator==(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y);
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y);
|
||||
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
class set
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Key, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept);
|
||||
|
||||
public:
|
||||
// typedefs:
|
||||
typedef _Key key_type;
|
||||
typedef _Key value_type;
|
||||
typedef _Compare key_compare;
|
||||
typedef _Compare value_compare;
|
||||
private:
|
||||
typedef _Rb_tree<key_type, value_type,
|
||||
_Identity<value_type>, key_compare, _Alloc> _Rep_type;
|
||||
_Rep_type _M_t; // red-black tree representing set
|
||||
public:
|
||||
typedef typename _Rep_type::const_pointer pointer;
|
||||
typedef typename _Rep_type::const_pointer const_pointer;
|
||||
typedef typename _Rep_type::const_reference reference;
|
||||
typedef typename _Rep_type::const_reference const_reference;
|
||||
typedef typename _Rep_type::const_iterator iterator;
|
||||
typedef typename _Rep_type::const_iterator const_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
|
||||
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename _Rep_type::size_type size_type;
|
||||
typedef typename _Rep_type::difference_type difference_type;
|
||||
typedef typename _Rep_type::allocator_type allocator_type;
|
||||
|
||||
// allocation/deallocation
|
||||
|
||||
set() : _M_t(_Compare(), allocator_type()) {}
|
||||
explicit set(const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
set(_InputIterator __first, _InputIterator __last)
|
||||
: _M_t(_Compare(), allocator_type())
|
||||
{ _M_t.insert_unique(__first, __last); }
|
||||
|
||||
template <class _InputIterator>
|
||||
set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
|
||||
|
||||
set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
|
||||
set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _Compare, _Alloc>& __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 _M_t.get_allocator(); }
|
||||
|
||||
iterator begin() const { return _M_t.begin(); }
|
||||
iterator end() const { return _M_t.end(); }
|
||||
reverse_iterator rbegin() const { return _M_t.rbegin(); }
|
||||
reverse_iterator rend() const { return _M_t.rend(); }
|
||||
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(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
|
||||
|
||||
// insert/erase
|
||||
pair<iterator,bool> insert(const value_type& __x) {
|
||||
pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
|
||||
return pair<iterator, bool>(__p.first, __p.second);
|
||||
}
|
||||
iterator insert(iterator __position, const value_type& __x) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
return _M_t.insert_unique((_Rep_iterator&)__position, __x);
|
||||
}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last) {
|
||||
_M_t.insert_unique(__first, __last);
|
||||
}
|
||||
void erase(iterator __position) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
_M_t.erase((_Rep_iterator&)__position);
|
||||
}
|
||||
size_type erase(const key_type& __x) {
|
||||
return _M_t.erase(__x);
|
||||
}
|
||||
void erase(iterator __first, iterator __last) {
|
||||
typedef typename _Rep_type::iterator _Rep_iterator;
|
||||
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
|
||||
}
|
||||
void clear() { _M_t.clear(); }
|
||||
|
||||
// set operations:
|
||||
|
||||
size_type count(const key_type& __x) const {
|
||||
return _M_t.find(__x) == _M_t.end() ? 0 : 1;
|
||||
}
|
||||
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
//214. set::find() missing const overload
|
||||
iterator find(const key_type& __x) { return _M_t.find(__x); }
|
||||
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
iterator lower_bound(const key_type& __x) {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
const_iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
iterator upper_bound(const key_type& __x) {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
const_iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
#else
|
||||
iterator find(const key_type& __x) const { return _M_t.find(__x); }
|
||||
iterator lower_bound(const key_type& __x) const {
|
||||
return _M_t.lower_bound(__x);
|
||||
}
|
||||
iterator upper_bound(const key_type& __x) const {
|
||||
return _M_t.upper_bound(__x);
|
||||
}
|
||||
pair<iterator,iterator> equal_range(const key_type& __x) const {
|
||||
return _M_t.equal_range(__x);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class _K1, class _C1, class _A1>
|
||||
friend bool operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
|
||||
template <class _K1, class _C1, class _A1>
|
||||
friend bool operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
|
||||
};
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator==(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t == __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return __x._M_t < __y._M_t;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator!=(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator>(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator<=(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline bool operator>=(const set<_Key,_Compare,_Alloc>& __x,
|
||||
const set<_Key,_Compare,_Alloc>& __y) {
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Key, class _Compare, class _Alloc>
|
||||
inline void swap(set<_Key,_Compare,_Alloc>& __x,
|
||||
set<_Key,_Compare,_Alloc>& __y) {
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_SET_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
160
TBE/MinGW/include/c++/3.2.3/bits/stl_stack.h
Normal file
160
TBE/MinGW/include/c++/3.2.3/bits/stl_stack.h
Normal file
@@ -0,0 +1,160 @@
|
||||
// Stack implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_stack.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_STACK_H
|
||||
#define __GLIBCPP_INTERNAL_STACK_H
|
||||
|
||||
#include <bits/concept_check.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// Forward declarations of operators == and <, needed for friend declaration.
|
||||
|
||||
template <class _Tp,
|
||||
class _Sequence = deque<_Tp> >
|
||||
class stack;
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
|
||||
|
||||
|
||||
template <class _Tp, class _Sequence>
|
||||
class stack
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept)
|
||||
typedef typename _Sequence::value_type _Sequence_value_type;
|
||||
__glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
|
||||
|
||||
template <class _Tp1, class _Seq1>
|
||||
friend bool operator== (const stack<_Tp1, _Seq1>&,
|
||||
const stack<_Tp1, _Seq1>&);
|
||||
template <class _Tp1, class _Seq1>
|
||||
friend bool operator< (const stack<_Tp1, _Seq1>&,
|
||||
const stack<_Tp1, _Seq1>&);
|
||||
public:
|
||||
typedef typename _Sequence::value_type value_type;
|
||||
typedef typename _Sequence::size_type size_type;
|
||||
typedef _Sequence container_type;
|
||||
|
||||
typedef typename _Sequence::reference reference;
|
||||
typedef typename _Sequence::const_reference const_reference;
|
||||
protected:
|
||||
_Sequence c;
|
||||
public:
|
||||
stack() : c() {}
|
||||
explicit stack(const _Sequence& __s) : c(__s) {}
|
||||
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
reference top() { return c.back(); }
|
||||
const_reference top() const { return c.back(); }
|
||||
void push(const value_type& __x) { c.push_back(__x); }
|
||||
void pop() { c.pop_back(); }
|
||||
};
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return __x.c == __y.c;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return __x.c < __y.c;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Tp, class _Seq>
|
||||
bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
|
||||
{
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_STACK_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
149
TBE/MinGW/include/c++/3.2.3/bits/stl_tempbuf.h
Normal file
149
TBE/MinGW/include/c++/3.2.3/bits/stl_tempbuf.h
Normal file
@@ -0,0 +1,149 @@
|
||||
// Temporary buffer implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_tempbuf.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __GLIBCPP_INTERNAL_TEMPBUF_H
|
||||
#define __GLIBCPP_INTERNAL_TEMPBUF_H
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* This class is used in two places: stl_algo.h and ext/memory, where it
|
||||
* is wrapped as the temporary_buffer class. See temporary_buffer docs for
|
||||
* more notes.
|
||||
* @endif
|
||||
*/
|
||||
template <class _ForwardIterator, class _Tp>
|
||||
class _Temporary_buffer
|
||||
{
|
||||
// concept requirements
|
||||
__glibcpp_class_requires(_ForwardIterator, _ForwardIteratorConcept)
|
||||
|
||||
ptrdiff_t _M_original_len;
|
||||
ptrdiff_t _M_len;
|
||||
_Tp* _M_buffer;
|
||||
|
||||
// this is basically get_temporary_buffer() all over again
|
||||
void _M_allocate_buffer() {
|
||||
_M_original_len = _M_len;
|
||||
_M_buffer = 0;
|
||||
|
||||
if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp)))
|
||||
_M_len = INT_MAX / sizeof(_Tp);
|
||||
|
||||
while (_M_len > 0) {
|
||||
_M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
|
||||
if (_M_buffer)
|
||||
break;
|
||||
_M_len /= 2;
|
||||
}
|
||||
}
|
||||
|
||||
void _M_initialize_buffer(const _Tp&, __true_type) {}
|
||||
void _M_initialize_buffer(const _Tp& val, __false_type) {
|
||||
uninitialized_fill_n(_M_buffer, _M_len, val);
|
||||
}
|
||||
|
||||
public:
|
||||
/// As per Table mumble.
|
||||
ptrdiff_t size() const { return _M_len; }
|
||||
/// Returns the size requested by the constructor; may be >size().
|
||||
ptrdiff_t requested_size() const { return _M_original_len; }
|
||||
/// As per Table mumble.
|
||||
_Tp* begin() { return _M_buffer; }
|
||||
/// As per Table mumble.
|
||||
_Tp* end() { return _M_buffer + _M_len; }
|
||||
|
||||
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {
|
||||
// Workaround for a __type_traits bug in the pre-7.3 compiler.
|
||||
typedef typename __type_traits<_Tp>::has_trivial_default_constructor
|
||||
_Trivial;
|
||||
|
||||
try {
|
||||
_M_len = distance(__first, __last);
|
||||
_M_allocate_buffer();
|
||||
if (_M_len > 0)
|
||||
_M_initialize_buffer(*__first, _Trivial());
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
free(_M_buffer);
|
||||
_M_buffer = 0;
|
||||
_M_len = 0;
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
~_Temporary_buffer() {
|
||||
_Destroy(_M_buffer, _M_buffer + _M_len);
|
||||
free(_M_buffer);
|
||||
}
|
||||
|
||||
private:
|
||||
// Disable copy constructor and assignment operator.
|
||||
_Temporary_buffer(const _Temporary_buffer&) {}
|
||||
void operator=(const _Temporary_buffer&) {}
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* __GLIBCPP_INTERNAL_TEMPBUF_H */
|
||||
|
||||
248
TBE/MinGW/include/c++/3.2.3/bits/stl_threads.h
Normal file
248
TBE/MinGW/include/c++/3.2.3/bits/stl_threads.h
Normal file
@@ -0,0 +1,248 @@
|
||||
// Threading support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
* Copyright (c) 1997-1999
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_threads.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef __SGI_STL_INTERNAL_THREADS_H
|
||||
#define __SGI_STL_INTERNAL_THREADS_H
|
||||
|
||||
// The only supported threading model is GCC's own gthr.h abstraction layer.
|
||||
#include "bits/gthr.h"
|
||||
|
||||
#if defined (__WIN32)
|
||||
/* Declared in winbase.h */
|
||||
extern "C"
|
||||
long __attribute__ ((stdcall)) InterlockedExchange (long*, long);
|
||||
#endif
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Class _Refcount_Base provides a type, _RC_t, a data member,
|
||||
// _M_ref_count, and member functions _M_incr and _M_decr, which perform
|
||||
// atomic preincrement/predecrement. The constructor initializes
|
||||
// _M_ref_count.
|
||||
struct _Refcount_Base
|
||||
{
|
||||
// The type _RC_t
|
||||
typedef size_t _RC_t;
|
||||
|
||||
// The data member _M_ref_count
|
||||
volatile _RC_t _M_ref_count;
|
||||
|
||||
// Constructor
|
||||
__gthread_mutex_t _M_ref_count_lock;
|
||||
|
||||
_Refcount_Base(_RC_t __n) : _M_ref_count(__n)
|
||||
{
|
||||
#ifdef __GTHREAD_MUTEX_INIT
|
||||
__gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
|
||||
_M_ref_count_lock = __tmp;
|
||||
#elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
__GTHREAD_MUTEX_INIT_FUNCTION (&_M_ref_count_lock);
|
||||
#else
|
||||
#error __GTHREAD_MUTEX_INIT or __GTHREAD_MUTEX_INIT_FUNCTION should be defined by gthr.h abstraction layer, report problem to libstdc++@gcc.gnu.org.
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
_M_incr()
|
||||
{
|
||||
__gthread_mutex_lock(&_M_ref_count_lock);
|
||||
++_M_ref_count;
|
||||
__gthread_mutex_unlock(&_M_ref_count_lock);
|
||||
}
|
||||
|
||||
_RC_t
|
||||
_M_decr()
|
||||
{
|
||||
__gthread_mutex_lock(&_M_ref_count_lock);
|
||||
volatile _RC_t __tmp = --_M_ref_count;
|
||||
__gthread_mutex_unlock(&_M_ref_count_lock);
|
||||
return __tmp;
|
||||
}
|
||||
};
|
||||
|
||||
// Atomic swap on unsigned long
|
||||
// This is guaranteed to behave as though it were atomic only if all
|
||||
// possibly concurrent updates use _Atomic_swap.
|
||||
// In some cases the operation is emulated with a lock.
|
||||
#if defined (__GTHREAD_MUTEX_INIT)
|
||||
// This could be optimized to use the atomicity.h abstraction layer.
|
||||
// vyzo: simple _Atomic_swap implementation following the guidelines above
|
||||
// We use a template here only to get a unique initialized instance.
|
||||
template<int __dummy>
|
||||
struct _Swap_lock_struct
|
||||
{ static __gthread_mutex_t _S_swap_lock; };
|
||||
|
||||
template<int __dummy>
|
||||
__gthread_mutex_t
|
||||
_Swap_lock_struct<__dummy>::_S_swap_lock = __GTHREAD_MUTEX_INIT;
|
||||
|
||||
// This should be portable, but performance is expected to be quite
|
||||
// awful. This really needs platform specific code.
|
||||
inline unsigned long
|
||||
_Atomic_swap(unsigned long * __p, unsigned long __q)
|
||||
{
|
||||
__gthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
|
||||
unsigned long __result = *__p;
|
||||
*__p = __q;
|
||||
__gthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
|
||||
return __result;
|
||||
}
|
||||
#elif defined (__WIN32)
|
||||
inline unsigned long
|
||||
_Atomic_swap(unsigned long * __p, unsigned long __q)
|
||||
{
|
||||
return InterlockedExchange ((long *) __p, (long) __q);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Locking class. Note that this class *does not have a
|
||||
// constructor*. It must be initialized either statically, with
|
||||
// __STL_MUTEX_INITIALIZER, or dynamically, by explicitly calling
|
||||
// the _M_initialize member function. (This is similar to the ways
|
||||
// that a pthreads mutex can be initialized.) There are explicit
|
||||
// member functions for acquiring and releasing the lock.
|
||||
|
||||
// There is no constructor because static initialization is
|
||||
// essential for some uses, and only a class aggregate (see section
|
||||
// 8.5.1 of the C++ standard) can be initialized that way. That
|
||||
// means we must have no constructors, no base classes, no virtual
|
||||
// functions, and no private or protected members.
|
||||
|
||||
#if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
extern __gthread_mutex_t _GLIBCPP_mutex;
|
||||
extern __gthread_mutex_t *_GLIBCPP_mutex_address;
|
||||
extern __gthread_once_t _GLIBCPP_once;
|
||||
extern void _GLIBCPP_mutex_init (void);
|
||||
extern void _GLIBCPP_mutex_address_init (void);
|
||||
#endif
|
||||
|
||||
struct _STL_mutex_lock
|
||||
{
|
||||
// The class must be statically initialized with __STL_MUTEX_INITIALIZER.
|
||||
#if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
volatile int _M_init_flag;
|
||||
__gthread_once_t _M_once;
|
||||
#endif
|
||||
__gthread_mutex_t _M_lock;
|
||||
|
||||
void
|
||||
_M_initialize()
|
||||
{
|
||||
#ifdef __GTHREAD_MUTEX_INIT
|
||||
// There should be no code in this path given the usage rules above.
|
||||
#elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
if (_M_init_flag) return;
|
||||
if (__gthread_once (&_GLIBCPP_once, _GLIBCPP_mutex_init) != 0
|
||||
&& __gthread_active_p ())
|
||||
abort ();
|
||||
__gthread_mutex_lock (&_GLIBCPP_mutex);
|
||||
if (!_M_init_flag)
|
||||
{
|
||||
// Even though we have a global lock, we use __gthread_once to be
|
||||
// absolutely certain the _M_lock mutex is only initialized once on
|
||||
// multiprocessor systems.
|
||||
_GLIBCPP_mutex_address = &_M_lock;
|
||||
if (__gthread_once (&_M_once, _GLIBCPP_mutex_address_init) != 0
|
||||
&& __gthread_active_p ())
|
||||
abort ();
|
||||
_M_init_flag = 1;
|
||||
}
|
||||
__gthread_mutex_unlock (&_GLIBCPP_mutex);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
_M_acquire_lock()
|
||||
{
|
||||
#if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
if (!_M_init_flag) _M_initialize();
|
||||
#endif
|
||||
__gthread_mutex_lock(&_M_lock);
|
||||
}
|
||||
|
||||
void
|
||||
_M_release_lock()
|
||||
{
|
||||
#if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
if (!_M_init_flag) _M_initialize();
|
||||
#endif
|
||||
__gthread_mutex_unlock(&_M_lock);
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef __GTHREAD_MUTEX_INIT
|
||||
#define __STL_MUTEX_INITIALIZER = { __GTHREAD_MUTEX_INIT }
|
||||
#elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
|
||||
#ifdef __GTHREAD_MUTEX_INIT_DEFAULT
|
||||
#define __STL_MUTEX_INITIALIZER \
|
||||
= { 0, __GTHREAD_ONCE_INIT, __GTHREAD_MUTEX_INIT_DEFAULT }
|
||||
#else
|
||||
#define __STL_MUTEX_INITIALIZER = { 0, __GTHREAD_ONCE_INIT }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// A locking class that uses _STL_mutex_lock. The constructor takes a
|
||||
// reference to an _STL_mutex_lock, and acquires a lock. The
|
||||
// destructor releases the lock. It's not clear that this is exactly
|
||||
// the right functionality. It will probably change in the future.
|
||||
struct _STL_auto_lock
|
||||
{
|
||||
_STL_mutex_lock& _M_lock;
|
||||
|
||||
_STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock)
|
||||
{ _M_lock._M_acquire_lock(); }
|
||||
|
||||
~_STL_auto_lock() { _M_lock._M_release_lock(); }
|
||||
|
||||
private:
|
||||
void operator=(const _STL_auto_lock&);
|
||||
_STL_auto_lock(const _STL_auto_lock&);
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
1462
TBE/MinGW/include/c++/3.2.3/bits/stl_tree.h
Normal file
1462
TBE/MinGW/include/c++/3.2.3/bits/stl_tree.h
Normal file
File diff suppressed because it is too large
Load Diff
290
TBE/MinGW/include/c++/3.2.3/bits/stl_uninitialized.h
Normal file
290
TBE/MinGW/include/c++/3.2.3/bits/stl_uninitialized.h
Normal file
@@ -0,0 +1,290 @@
|
||||
// Raw memory manipulators -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1994
|
||||
* Hewlett-Packard Company
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Hewlett-Packard Company makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996,1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file stl_uninitialized.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STL_UNINITIALIZED_H
|
||||
#define _CPP_BITS_STL_UNINITIALIZED_H 1
|
||||
|
||||
#include <cstring>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
// uninitialized_copy
|
||||
|
||||
template<typename _InputIter, typename _ForwardIter>
|
||||
inline _ForwardIter
|
||||
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
|
||||
_ForwardIter __result,
|
||||
__true_type)
|
||||
{ return copy(__first, __last, __result); }
|
||||
|
||||
template<typename _InputIter, typename _ForwardIter>
|
||||
_ForwardIter
|
||||
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
|
||||
_ForwardIter __result,
|
||||
__false_type)
|
||||
{
|
||||
_ForwardIter __cur = __result;
|
||||
try {
|
||||
for ( ; __first != __last; ++__first, ++__cur)
|
||||
_Construct(&*__cur, *__first);
|
||||
return __cur;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__result, __cur);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copies the range [first,last) into result.
|
||||
* @param first An input iterator.
|
||||
* @param last An input iterator.
|
||||
* @param result An output iterator.
|
||||
* @return result + (first - last)
|
||||
*
|
||||
* Like copy(), but does not require an initialized output range.
|
||||
*/
|
||||
template<typename _InputIter, typename _ForwardIter>
|
||||
inline _ForwardIter
|
||||
uninitialized_copy(_InputIter __first, _InputIter __last, _ForwardIter __result)
|
||||
{
|
||||
typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
|
||||
typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
|
||||
return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
|
||||
}
|
||||
|
||||
inline char*
|
||||
uninitialized_copy(const char* __first, const char* __last, char* __result)
|
||||
{
|
||||
memmove(__result, __first, __last - __first);
|
||||
return __result + (__last - __first);
|
||||
}
|
||||
|
||||
inline wchar_t*
|
||||
uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
|
||||
wchar_t* __result)
|
||||
{
|
||||
memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
|
||||
return __result + (__last - __first);
|
||||
}
|
||||
|
||||
// Valid if copy construction is equivalent to assignment, and if the
|
||||
// destructor is trivial.
|
||||
template<typename _ForwardIter, typename _Tp>
|
||||
inline void
|
||||
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
|
||||
const _Tp& __x, __true_type)
|
||||
{ fill(__first, __last, __x); }
|
||||
|
||||
template<typename _ForwardIter, typename _Tp>
|
||||
void
|
||||
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
|
||||
const _Tp& __x, __false_type)
|
||||
{
|
||||
_ForwardIter __cur = __first;
|
||||
try {
|
||||
for ( ; __cur != __last; ++__cur)
|
||||
_Construct(&*__cur, __x);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__first, __cur);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copies the value x into the range [first,last).
|
||||
* @param first An input iterator.
|
||||
* @param last An input iterator.
|
||||
* @param x The source value.
|
||||
* @return Nothing.
|
||||
*
|
||||
* Like fill(), but does not require an initialized output range.
|
||||
*/
|
||||
template<typename _ForwardIter, typename _Tp>
|
||||
inline void
|
||||
uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x)
|
||||
{
|
||||
typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
|
||||
typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
|
||||
__uninitialized_fill_aux(__first, __last, __x, _Is_POD());
|
||||
}
|
||||
|
||||
// Valid if copy construction is equivalent to assignment, and if the
|
||||
// destructor is trivial.
|
||||
template<typename _ForwardIter, typename _Size, typename _Tp>
|
||||
inline _ForwardIter
|
||||
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
|
||||
const _Tp& __x, __true_type)
|
||||
{
|
||||
return fill_n(__first, __n, __x);
|
||||
}
|
||||
|
||||
template<typename _ForwardIter, typename _Size, typename _Tp>
|
||||
_ForwardIter
|
||||
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
|
||||
const _Tp& __x, __false_type)
|
||||
{
|
||||
_ForwardIter __cur = __first;
|
||||
try {
|
||||
for ( ; __n > 0; --__n, ++__cur)
|
||||
_Construct(&*__cur, __x);
|
||||
return __cur;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__first, __cur);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copies the value x into the range [first,first+n).
|
||||
* @param first An input iterator.
|
||||
* @param n The number of copies to make.
|
||||
* @param x The source value.
|
||||
* @return first+n
|
||||
*
|
||||
* Like fill_n(), but does not require an initialized output range.
|
||||
*/
|
||||
template<typename _ForwardIter, typename _Size, typename _Tp>
|
||||
inline _ForwardIter
|
||||
uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
|
||||
{
|
||||
typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
|
||||
typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
|
||||
return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
|
||||
}
|
||||
|
||||
// Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill,
|
||||
// __uninitialized_fill_copy.
|
||||
|
||||
// __uninitialized_copy_copy
|
||||
// Copies [first1, last1) into [result, result + (last1 - first1)), and
|
||||
// copies [first2, last2) into
|
||||
// [result, result + (last1 - first1) + (last2 - first2)).
|
||||
|
||||
template<typename _InputIter1, typename _InputIter2, typename _ForwardIter>
|
||||
inline _ForwardIter
|
||||
__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
|
||||
_InputIter2 __first2, _InputIter2 __last2,
|
||||
_ForwardIter __result)
|
||||
{
|
||||
_ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
|
||||
try {
|
||||
return uninitialized_copy(__first2, __last2, __mid);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__result, __mid);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
// __uninitialized_fill_copy
|
||||
// Fills [result, mid) with x, and copies [first, last) into
|
||||
// [mid, mid + (last - first)).
|
||||
template<typename _ForwardIter, typename _Tp, typename _InputIter>
|
||||
inline _ForwardIter
|
||||
__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
|
||||
const _Tp& __x,
|
||||
_InputIter __first, _InputIter __last)
|
||||
{
|
||||
uninitialized_fill(__result, __mid, __x);
|
||||
try {
|
||||
return uninitialized_copy(__first, __last, __mid);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__result, __mid);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
// __uninitialized_copy_fill
|
||||
// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
|
||||
// fills [first2 + (last1 - first1), last2) with x.
|
||||
template<typename _InputIter, typename _ForwardIter, typename _Tp>
|
||||
inline void
|
||||
__uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
|
||||
_ForwardIter __first2, _ForwardIter __last2,
|
||||
const _Tp& __x)
|
||||
{
|
||||
_ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
|
||||
try {
|
||||
uninitialized_fill(__mid2, __last2, __x);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
_Destroy(__first2, __mid2);
|
||||
__throw_exception_again;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif /* _CPP_BITS_STL_UNINITIALIZED_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
1085
TBE/MinGW/include/c++/3.2.3/bits/stl_vector.h
Normal file
1085
TBE/MinGW/include/c++/3.2.3/bits/stl_vector.h
Normal file
File diff suppressed because it is too large
Load Diff
156
TBE/MinGW/include/c++/3.2.3/bits/stream_iterator.h
Normal file
156
TBE/MinGW/include/c++/3.2.3/bits/stream_iterator.h
Normal file
@@ -0,0 +1,156 @@
|
||||
// Stream iterators
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/** @file stream_iterator.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STREAM_ITERATOR_H
|
||||
#define _CPP_BITS_STREAM_ITERATOR_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _Tp, typename _CharT = char,
|
||||
typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
|
||||
class istream_iterator
|
||||
: public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
|
||||
{
|
||||
public:
|
||||
typedef _CharT char_type;
|
||||
typedef _Traits traits_type;
|
||||
typedef basic_istream<_CharT, _Traits> istream_type;
|
||||
|
||||
private:
|
||||
istream_type* _M_stream;
|
||||
_Tp _M_value;
|
||||
bool _M_ok;
|
||||
|
||||
public:
|
||||
istream_iterator() : _M_stream(0), _M_ok(false) {}
|
||||
|
||||
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),
|
||||
_M_ok(__obj._M_ok)
|
||||
{ }
|
||||
|
||||
const _Tp&
|
||||
operator*() const { return _M_value; }
|
||||
|
||||
const _Tp*
|
||||
operator->() const { return &(operator*()); }
|
||||
|
||||
istream_iterator&
|
||||
operator++()
|
||||
{ _M_read(); return *this; }
|
||||
|
||||
istream_iterator
|
||||
operator++(int)
|
||||
{
|
||||
istream_iterator __tmp = *this;
|
||||
_M_read();
|
||||
return __tmp;
|
||||
}
|
||||
|
||||
bool
|
||||
_M_equal(const istream_iterator& __x) const
|
||||
{ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);}
|
||||
|
||||
private:
|
||||
void
|
||||
_M_read()
|
||||
{
|
||||
_M_ok = (_M_stream && *_M_stream) ? true : false;
|
||||
if (_M_ok)
|
||||
{
|
||||
*_M_stream >> _M_value;
|
||||
_M_ok = *_M_stream ? true : false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
|
||||
inline bool
|
||||
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
|
||||
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
|
||||
{ return __x._M_equal(__y); }
|
||||
|
||||
template <class _Tp, class _CharT, class _Traits, class _Dist>
|
||||
inline bool
|
||||
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
|
||||
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
|
||||
{ return !__x._M_equal(__y); }
|
||||
|
||||
|
||||
template<typename _Tp, typename _CharT = char,
|
||||
typename _Traits = char_traits<_CharT> >
|
||||
class ostream_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
public:
|
||||
typedef _CharT char_type;
|
||||
typedef _Traits traits_type;
|
||||
typedef basic_ostream<_CharT, _Traits> ostream_type;
|
||||
|
||||
private:
|
||||
ostream_type* _M_stream;
|
||||
const _CharT* _M_string;
|
||||
|
||||
public:
|
||||
ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
|
||||
|
||||
ostream_iterator(ostream_type& __s, const _CharT* __c)
|
||||
: _M_stream(&__s), _M_string(__c) { }
|
||||
|
||||
ostream_iterator(const ostream_iterator& __obj)
|
||||
: _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
|
||||
|
||||
ostream_iterator&
|
||||
operator=(const _Tp& __value)
|
||||
{
|
||||
*_M_stream << __value;
|
||||
if (_M_string) *_M_stream << _M_string;
|
||||
return *this;
|
||||
}
|
||||
|
||||
ostream_iterator&
|
||||
operator*() { return *this; }
|
||||
|
||||
ostream_iterator&
|
||||
operator++() { return *this; }
|
||||
|
||||
ostream_iterator&
|
||||
operator++(int) { return *this; }
|
||||
};
|
||||
} // namespace std
|
||||
#endif
|
||||
264
TBE/MinGW/include/c++/3.2.3/bits/streambuf.tcc
Normal file
264
TBE/MinGW/include/c++/3.2.3/bits/streambuf.tcc
Normal file
@@ -0,0 +1,264 @@
|
||||
// Stream buffer classes -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 27.5 Stream buffers
|
||||
//
|
||||
|
||||
#ifndef _CPP_BITS_STREAMBUF_TCC
|
||||
#define _CPP_BITS_STREAMBUF_TCC 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _CharT, typename _Traits>
|
||||
const size_t
|
||||
basic_streambuf<_CharT, _Traits>::_S_pback_size;
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::int_type
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
sbumpc()
|
||||
{
|
||||
int_type __ret;
|
||||
if (_M_in_cur && _M_in_cur < _M_in_end)
|
||||
{
|
||||
char_type __c = *(this->gptr());
|
||||
_M_in_cur_move(1);
|
||||
__ret = traits_type::to_int_type(__c);
|
||||
}
|
||||
else
|
||||
__ret = this->uflow();
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::int_type
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
sputbackc(char_type __c)
|
||||
{
|
||||
int_type __ret;
|
||||
bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
|
||||
if (!__testpos || !traits_type::eq(__c, this->gptr()[-1]))
|
||||
__ret = this->pbackfail(traits_type::to_int_type(__c));
|
||||
else
|
||||
{
|
||||
_M_in_cur_move(-1);
|
||||
__ret = traits_type::to_int_type(*this->gptr());
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::int_type
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
sungetc()
|
||||
{
|
||||
int_type __ret;
|
||||
if (_M_in_cur && _M_in_beg < _M_in_cur)
|
||||
{
|
||||
_M_in_cur_move(-1);
|
||||
__ret = traits_type::to_int_type(*_M_in_cur);
|
||||
}
|
||||
else
|
||||
__ret = this->pbackfail();
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Don't test against _M_buf + _M_buf_size, because _M_buf reflects
|
||||
// allocated space, and on certain (rare but entirely legal)
|
||||
// situations, there will be no allocated space yet the internal
|
||||
// buffers will still be valid. (This happens if setp is used to set
|
||||
// the internal buffer to say some externally-allocated sequence.)
|
||||
template<typename _CharT, typename _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::int_type
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
sputc(char_type __c)
|
||||
{
|
||||
int_type __ret;
|
||||
if (_M_out_buf_size())
|
||||
{
|
||||
*_M_out_cur = __c;
|
||||
_M_out_cur_move(1);
|
||||
__ret = traits_type::to_int_type(__c);
|
||||
}
|
||||
else
|
||||
__ret = this->overflow(traits_type::to_int_type(__c));
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
streamsize
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
xsgetn(char_type* __s, streamsize __n)
|
||||
{
|
||||
streamsize __ret = 0;
|
||||
while (__ret < __n)
|
||||
{
|
||||
size_t __buf_len = _M_in_end - _M_in_cur;
|
||||
if (__buf_len > 0)
|
||||
{
|
||||
size_t __remaining = __n - __ret;
|
||||
size_t __len = min(__buf_len, __remaining);
|
||||
traits_type::copy(__s, _M_in_cur, __len);
|
||||
__ret += __len;
|
||||
__s += __len;
|
||||
_M_in_cur_move(__len);
|
||||
}
|
||||
|
||||
if (__ret < __n)
|
||||
{
|
||||
int_type __c = this->uflow();
|
||||
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
||||
{
|
||||
traits_type::assign(*__s++, traits_type::to_char_type(__c));
|
||||
++__ret;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Don't test against _M_buf + _M_buf_size, because _M_buf reflects
|
||||
// allocated space, and on certain (rare but entirely legal)
|
||||
// situations, there will be no allocated space yet the internal
|
||||
// buffers will still be valid. (This happens if setp is used to set
|
||||
// the internal buffer to say some externally-allocated sequence.)
|
||||
template<typename _CharT, typename _Traits>
|
||||
streamsize
|
||||
basic_streambuf<_CharT, _Traits>::
|
||||
xsputn(const char_type* __s, streamsize __n)
|
||||
{
|
||||
streamsize __ret = 0;
|
||||
while (__ret < __n)
|
||||
{
|
||||
off_type __buf_len = _M_out_buf_size();
|
||||
if (__buf_len > 0)
|
||||
{
|
||||
off_type __remaining = __n - __ret;
|
||||
off_type __len = min(__buf_len, __remaining);
|
||||
traits_type::copy(_M_out_cur, __s, __len);
|
||||
__ret += __len;
|
||||
__s += __len;
|
||||
_M_out_cur_move(__len);
|
||||
}
|
||||
|
||||
if (__ret < __n)
|
||||
{
|
||||
int_type __c = this->overflow(traits_type::to_int_type(*__s));
|
||||
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
||||
{
|
||||
++__ret;
|
||||
++__s;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Conceivably, this could be used to implement buffer-to-buffer
|
||||
// copies, if this was ever desired in an un-ambiguous way by the
|
||||
// standard. If so, then checks for __ios being zero would be
|
||||
// necessary.
|
||||
template<typename _CharT, typename _Traits>
|
||||
streamsize
|
||||
__copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
|
||||
basic_streambuf<_CharT, _Traits>* __sbin,
|
||||
basic_streambuf<_CharT, _Traits>* __sbout)
|
||||
{
|
||||
typedef typename _Traits::int_type int_type;
|
||||
|
||||
streamsize __ret = 0;
|
||||
streamsize __bufsize = __sbin->in_avail();
|
||||
streamsize __xtrct;
|
||||
bool __testput = __sbout->_M_mode & ios_base::out;
|
||||
try
|
||||
{
|
||||
while (__testput && __bufsize != -1)
|
||||
{
|
||||
if (__bufsize != 0 && __sbin->gptr() != NULL
|
||||
&& __sbin->gptr() + __bufsize <= __sbin->egptr())
|
||||
{
|
||||
__xtrct = __sbout->sputn(__sbin->gptr(), __bufsize);
|
||||
__ret += __xtrct;
|
||||
__sbin->_M_in_cur_move(__xtrct);
|
||||
if (__xtrct != __bufsize)
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t __size =
|
||||
__sbin->_M_buf_size_opt > 0 ? __sbin->_M_buf_size_opt : 1;
|
||||
_CharT* __buf =
|
||||
static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __size));
|
||||
streamsize __charsread = __sbin->sgetn(__buf, __size);
|
||||
__xtrct = __sbout->sputn(__buf, __charsread);
|
||||
__ret += __xtrct;
|
||||
if (__xtrct != __charsread)
|
||||
break;
|
||||
}
|
||||
if (_Traits::eq_int_type(__sbin->sgetc(), _Traits::eof()))
|
||||
break;
|
||||
__bufsize = __sbin->in_avail();
|
||||
}
|
||||
}
|
||||
catch(exception& __fail)
|
||||
{
|
||||
__ios.setstate(ios_base::failbit);
|
||||
if ((__ios.exceptions() & ios_base::failbit) != 0)
|
||||
__throw_exception_again;
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
// Inhibit implicit instantiations for required instantiations,
|
||||
// which are defined via explicit instantiations elsewhere.
|
||||
// NB: This syntax is a GNU extension.
|
||||
extern template class basic_streambuf<char>;
|
||||
extern template
|
||||
streamsize
|
||||
__copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
|
||||
basic_streambuf<char>*);
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
extern template class basic_streambuf<wchar_t>;
|
||||
extern template
|
||||
streamsize
|
||||
__copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
|
||||
basic_streambuf<wchar_t>*);
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
206
TBE/MinGW/include/c++/3.2.3/bits/streambuf_iterator.h
Normal file
206
TBE/MinGW/include/c++/3.2.3/bits/streambuf_iterator.h
Normal file
@@ -0,0 +1,206 @@
|
||||
// Streambuf iterators
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// XXX Should specialize copy, find algorithms for streambuf iterators.
|
||||
|
||||
/** @file streambuf_iterator.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STREAMBUF_ITERATOR_H
|
||||
#define _CPP_BITS_STREAMBUF_ITERATOR_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
namespace std
|
||||
{
|
||||
// 24.5.3 Template class istreambuf_iterator
|
||||
template<typename _CharT, typename _Traits>
|
||||
class istreambuf_iterator
|
||||
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
|
||||
_CharT*, _CharT&>
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef _CharT char_type;
|
||||
typedef _Traits traits_type;
|
||||
typedef typename _Traits::int_type int_type;
|
||||
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
|
||||
typedef basic_istream<_CharT, _Traits> istream_type;
|
||||
|
||||
private:
|
||||
// 24.5.3 istreambuf_iterator
|
||||
// p 1
|
||||
// If the end of stream is reached (streambuf_type::sgetc()
|
||||
// returns traits_type::eof()), the iterator becomes equal to
|
||||
// the "end of stream" iterator value.
|
||||
// NB: This implementation assumes the "end of stream" value
|
||||
// is EOF, or -1.
|
||||
mutable streambuf_type* _M_sbuf;
|
||||
int_type _M_c;
|
||||
|
||||
public:
|
||||
istreambuf_iterator() throw()
|
||||
: _M_sbuf(0), _M_c(traits_type::eof()) { }
|
||||
|
||||
istreambuf_iterator(istream_type& __s) throw()
|
||||
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
|
||||
|
||||
istreambuf_iterator(streambuf_type* __s) throw()
|
||||
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
|
||||
|
||||
// NB: The result of operator*() on an end of stream is undefined.
|
||||
char_type
|
||||
operator*() const
|
||||
{ return traits_type::to_char_type(_M_get()); }
|
||||
|
||||
istreambuf_iterator&
|
||||
operator++()
|
||||
{
|
||||
const int_type __eof = traits_type::eof();
|
||||
if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
|
||||
_M_sbuf = 0;
|
||||
else
|
||||
_M_c = __eof;
|
||||
return *this;
|
||||
}
|
||||
|
||||
istreambuf_iterator
|
||||
operator++(int)
|
||||
{
|
||||
const int_type __eof = traits_type::eof();
|
||||
istreambuf_iterator __old = *this;
|
||||
if (_M_sbuf
|
||||
&& traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
|
||||
__eof))
|
||||
_M_sbuf = 0;
|
||||
else
|
||||
_M_c = __eof;
|
||||
return __old;
|
||||
}
|
||||
|
||||
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
||||
// 110 istreambuf_iterator::equal not const
|
||||
// NB: there is also number 111 (NAD, Future) pending on this function.
|
||||
bool
|
||||
equal(const istreambuf_iterator& __b) const
|
||||
{
|
||||
const int_type __eof = traits_type::eof();
|
||||
bool __thiseof = traits_type::eq_int_type(_M_get(), __eof);
|
||||
bool __beof = traits_type::eq_int_type(__b._M_get(), __eof);
|
||||
return (__thiseof && __beof || (!__thiseof && !__beof));
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
int_type
|
||||
_M_get() const
|
||||
{
|
||||
const int_type __eof = traits_type::eof();
|
||||
int_type __ret = __eof;
|
||||
if (_M_sbuf)
|
||||
{
|
||||
if (!traits_type::eq_int_type(_M_c, __eof))
|
||||
__ret = _M_c;
|
||||
else
|
||||
if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
|
||||
_M_sbuf = 0;
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
inline bool
|
||||
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
|
||||
const istreambuf_iterator<_CharT, _Traits>& __b)
|
||||
{ return __a.equal(__b); }
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
inline bool
|
||||
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
|
||||
const istreambuf_iterator<_CharT, _Traits>& __b)
|
||||
{ return !__a.equal(__b); }
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
class ostreambuf_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef _CharT char_type;
|
||||
typedef _Traits traits_type;
|
||||
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
|
||||
typedef basic_ostream<_CharT, _Traits> ostream_type;
|
||||
|
||||
private:
|
||||
streambuf_type* _M_sbuf;
|
||||
bool _M_failed;
|
||||
|
||||
public:
|
||||
inline
|
||||
ostreambuf_iterator(ostream_type& __s) throw ()
|
||||
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
|
||||
|
||||
ostreambuf_iterator(streambuf_type* __s) throw ()
|
||||
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
|
||||
|
||||
ostreambuf_iterator&
|
||||
operator=(_CharT __c);
|
||||
|
||||
ostreambuf_iterator&
|
||||
operator*() throw()
|
||||
{ return *this; }
|
||||
|
||||
ostreambuf_iterator&
|
||||
operator++(int) throw()
|
||||
{ return *this; }
|
||||
|
||||
ostreambuf_iterator&
|
||||
operator++() throw()
|
||||
{ return *this; }
|
||||
|
||||
bool
|
||||
failed() const throw()
|
||||
{ return _M_failed; }
|
||||
};
|
||||
|
||||
template<typename _CharT, typename _Traits>
|
||||
inline ostreambuf_iterator<_CharT, _Traits>&
|
||||
ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c)
|
||||
{
|
||||
if (!_M_failed &&
|
||||
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
|
||||
_M_failed = true;
|
||||
return *this;
|
||||
}
|
||||
} // namespace std
|
||||
#endif
|
||||
69
TBE/MinGW/include/c++/3.2.3/bits/stringfwd.h
Normal file
69
TBE/MinGW/include/c++/3.2.3/bits/stringfwd.h
Normal file
@@ -0,0 +1,69 @@
|
||||
// String support -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: 21 Strings library
|
||||
//
|
||||
|
||||
/** @file stringfwd.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_STRINGFWD_H
|
||||
#define _CPP_BITS_STRINGFWD_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++config.h>
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<typename _Alloc>
|
||||
class allocator;
|
||||
|
||||
template<class _CharT>
|
||||
struct char_traits;
|
||||
|
||||
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
||||
typename _Alloc = allocator<_CharT> >
|
||||
class basic_string;
|
||||
|
||||
template<> struct char_traits<char>;
|
||||
|
||||
typedef basic_string<char> string;
|
||||
|
||||
#ifdef _GLIBCPP_USE_WCHAR_T
|
||||
template<> struct char_traits<wchar_t>;
|
||||
|
||||
typedef basic_string<wchar_t> wstring;
|
||||
#endif
|
||||
} // namespace std
|
||||
|
||||
#endif // _CPP_BITS_STRINGFWD_H
|
||||
339
TBE/MinGW/include/c++/3.2.3/bits/type_traits.h
Normal file
339
TBE/MinGW/include/c++/3.2.3/bits/type_traits.h
Normal file
@@ -0,0 +1,339 @@
|
||||
// Type traits implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Silicon Graphics Computer Systems, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Silicon Graphics makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
/** @file type_traits.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_TYPE_TRAITS_H
|
||||
#define _CPP_BITS_TYPE_TRAITS_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++config.h>
|
||||
|
||||
/*
|
||||
This header file provides a framework for allowing compile time dispatch
|
||||
based on type attributes. This is useful when writing template code.
|
||||
For example, when making a copy of an array of an unknown type, it helps
|
||||
to know if the type has a trivial copy constructor or not, to help decide
|
||||
if a memcpy can be used.
|
||||
|
||||
The class template __type_traits provides a series of typedefs each of
|
||||
which is either __true_type or __false_type. The argument to
|
||||
__type_traits can be any type. The typedefs within this template will
|
||||
attain their correct values by one of these means:
|
||||
1. The general instantiation contain conservative values which work
|
||||
for all types.
|
||||
2. Specializations may be declared to make distinctions between types.
|
||||
3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
|
||||
will automatically provide the appropriate specializations for all
|
||||
types.
|
||||
|
||||
EXAMPLE:
|
||||
|
||||
//Copy an array of elements which have non-trivial copy constructors
|
||||
template <class _Tp> void
|
||||
copy(_Tp* __source,_Tp* __destination,int __n,__false_type);
|
||||
//Copy an array of elements which have trivial copy constructors. Use memcpy.
|
||||
template <class _Tp> void
|
||||
copy(_Tp* __source,_Tp* __destination,int __n,__true_type);
|
||||
|
||||
//Copy an array of any type by using the most efficient copy mechanism
|
||||
template <class _Tp> inline void copy(_Tp* __source,_Tp* __destination,int __n) {
|
||||
copy(__source,__destination,__n,
|
||||
typename __type_traits<_Tp>::has_trivial_copy_constructor());
|
||||
}
|
||||
*/
|
||||
|
||||
struct __true_type {};
|
||||
struct __false_type {};
|
||||
|
||||
template <class _Tp>
|
||||
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
|
||||
__type_traits template is special. It just makes sure that
|
||||
things work if an implementation is using a template
|
||||
called __type_traits for something unrelated. */
|
||||
|
||||
/* The following restrictions should be observed for the sake of
|
||||
compilers which automatically produce type specific specializations
|
||||
of this class:
|
||||
- You may reorder the members below if you wish
|
||||
- You may remove any of the members below if you wish
|
||||
- You must not rename members without making the corresponding
|
||||
name change in the compiler
|
||||
- Members you add will be treated like regular members unless
|
||||
you add the appropriate support in the compiler. */
|
||||
|
||||
|
||||
typedef __false_type has_trivial_default_constructor;
|
||||
typedef __false_type has_trivial_copy_constructor;
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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> {
|
||||
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*> {
|
||||
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 {
|
||||
typedef __false_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<bool> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<char> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<signed char> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<unsigned char> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<wchar_t> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<short> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<unsigned short> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<int> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<unsigned int> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<long> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<unsigned long> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<long long> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
template<> struct _Is_integer<unsigned long long> {
|
||||
typedef __true_type _Integral;
|
||||
};
|
||||
|
||||
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>
|
||||
struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, _Container> > {
|
||||
typedef __true_type _Normal;
|
||||
};
|
||||
|
||||
#endif /* _CPP_BITS_TYPE_TRAITS_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:C++
|
||||
// End:
|
||||
630
TBE/MinGW/include/c++/3.2.3/bits/valarray_array.h
Normal file
630
TBE/MinGW/include/c++/3.2.3/bits/valarray_array.h
Normal file
@@ -0,0 +1,630 @@
|
||||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000 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
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
/** @file valarray_array.h
|
||||
* This is an internal header file, included by other library headers.
|
||||
* You should not attempt to use it directly.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_BITS_ARRAY_H
|
||||
#define _CPP_BITS_ARRAY_H 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <bits/c++config.h>
|
||||
#include <bits/cpp_type_traits.h>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <new>
|
||||
|
||||
namespace std
|
||||
{
|
||||
//
|
||||
// Helper functions on raw pointers
|
||||
//
|
||||
|
||||
// We get memory by the old fashion way
|
||||
inline void*
|
||||
__valarray_get_memory(size_t __n)
|
||||
{ return operator new(__n); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*__restrict__
|
||||
__valarray_get_storage(size_t __n)
|
||||
{
|
||||
return static_cast<_Tp*__restrict__>
|
||||
(__valarray_get_memory(__n * sizeof(_Tp)));
|
||||
}
|
||||
|
||||
// Return memory to the system
|
||||
inline void
|
||||
__valarray_release_memory(void* __p)
|
||||
{ operator delete(__p); }
|
||||
|
||||
// Turn a raw-memory into an array of _Tp filled with _Tp()
|
||||
// This is required in 'valarray<T> v(n);'
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_default_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// valarrays aren't required to be exception safe.
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{ while (__b != __e) new(__b++) _Tp(); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_default_ctor<_Tp, true>
|
||||
{
|
||||
// For fundamental types, it suffices to say 'memset()'
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{ memset(__b, 0, (__e - __b)*sizeof(_Tp)); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
_Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e);
|
||||
}
|
||||
|
||||
// Turn a raw-memory into an array of _Tp filled with __t
|
||||
// This is the required in valarray<T> v(n, t). Also
|
||||
// used in valarray<>::resize().
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_init_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// valarrays aren't required to be exception safe.
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
|
||||
{ while (__b != __e) new(__b++) _Tp(__t); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_init_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
|
||||
{ while (__b != __e) *__b++ = __t; }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e,
|
||||
const _Tp __t)
|
||||
{
|
||||
_Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __t);
|
||||
}
|
||||
|
||||
//
|
||||
// copy-construct raw array [__o, *) from plain array [__b, __e)
|
||||
// We can't just say 'memcpy()'
|
||||
//
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_copy_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// valarrays aren't required to be exception safe.
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{ while (__b != __e) new(__o++) _Tp(*__b++); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_copy_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{ memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct(const _Tp* __restrict__ __b,
|
||||
const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{
|
||||
_Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __o);
|
||||
}
|
||||
|
||||
// copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, _Tp* __restrict__ __o)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--) { *__o++ = *__a; __a += __s; }
|
||||
else
|
||||
while (__n--) { new(__o++) _Tp(*__a); __a += __s; }
|
||||
}
|
||||
|
||||
// copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __o, size_t __n)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--) *__o++ = __a[*__i++];
|
||||
else
|
||||
while (__n--) new (__o++) _Tp(__a[*__i++]);
|
||||
}
|
||||
|
||||
// Do the necessary cleanup when we're done with arrays.
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
if (!__is_fundamental<_Tp>::_M_type)
|
||||
while (__b != __e) { __b->~_Tp(); ++__b; }
|
||||
}
|
||||
|
||||
// Fill a plain array __a[<__n>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
|
||||
{ while (__n--) *__a++ = __t; }
|
||||
|
||||
// fill strided array __a[<__n-1 : __s>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, const _Tp& __t)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; }
|
||||
|
||||
// fill indir ect array __a[__i[<__n>]] with __i
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; }
|
||||
|
||||
// copy plain array __a[<__n>] in __b[<__n>]
|
||||
// For non-fundamental types, it is wrong to say 'memcpy()'
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_copier
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{ while (__n--) *__b++ = *__a++; }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_copier<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{ memcpy (__b, __a, __n * sizeof (_Tp)); }
|
||||
};
|
||||
|
||||
// Copy a plain array __a[<__n>] into a play array __b[<>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b)
|
||||
{
|
||||
_Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__a, __n, __b);
|
||||
}
|
||||
|
||||
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
|
||||
_Tp* __restrict__ __b)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; }
|
||||
|
||||
// Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
|
||||
size_t __n, size_t __s)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; }
|
||||
|
||||
// Copy strided array __src[<__n : __s1>] into another
|
||||
// strided array __dst[< : __s2>]. Their sizes must match.
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
|
||||
_Tp* __restrict__ __dst, size_t __s2)
|
||||
{
|
||||
for (size_t __i = 0; __i < __n; ++__i)
|
||||
__dst[__i * __s2] = __src [ __i * __s1];
|
||||
}
|
||||
|
||||
|
||||
// Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __b, size_t __n)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; }
|
||||
|
||||
// Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b, const size_t* __restrict__ __i)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; }
|
||||
|
||||
// Copy the __n first elements of an indexed array __src[<__i>] into
|
||||
// another indexed array __dst[<__j>].
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __src, size_t __n,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __dst, const size_t* __restrict__ __j)
|
||||
{
|
||||
for (size_t __k = 0; __k < __n; ++__k)
|
||||
__dst[*__j++] = __src[*__i++];
|
||||
}
|
||||
|
||||
//
|
||||
// Compute the sum of elements in range [__f, __l)
|
||||
// This is a naive algorithm. It suffers from cancelling.
|
||||
// In the future try to specialize
|
||||
// for _Tp = float, double, long double using a more accurate
|
||||
// algorithm.
|
||||
//
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
__valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp();
|
||||
while (__f != __l) __r += *__f++;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Compute the product of all elements in range [__f, __l)
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
__valarray_product(const _Tp* __restrict__ __f,
|
||||
const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp(1);
|
||||
while (__f != __l) __r = __r * *__f++;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Compute the min/max of an array-expression
|
||||
template<typename _Ta>
|
||||
inline typename _Ta::value_type
|
||||
__valarray_min(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t < __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
template<typename _Ta>
|
||||
inline typename _Ta::value_type
|
||||
__valarray_max(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t > __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
//
|
||||
// Helper class _Array, first layer of valarray abstraction.
|
||||
// All operations on valarray should be forwarded to this class
|
||||
// whenever possible. -- gdr
|
||||
//
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array
|
||||
{
|
||||
explicit _Array (size_t);
|
||||
explicit _Array (_Tp* const __restrict__);
|
||||
explicit _Array (const valarray<_Tp>&);
|
||||
_Array (const _Tp* __restrict__, size_t);
|
||||
|
||||
_Tp* begin () const;
|
||||
|
||||
_Tp* const __restrict__ _M_data;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __s, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __i._M_data, __n, __t); }
|
||||
|
||||
// Copy a plain array __a[<__n>] into a play array __b[<>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
|
||||
{ __valarray_copy(__a._M_data, __n, __b._M_data); }
|
||||
|
||||
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
|
||||
{ __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
|
||||
|
||||
// Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
|
||||
{ __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
|
||||
|
||||
// Copy strided array __src[<__n : __s1>] into another
|
||||
// strided array __dst[< : __s2>]. Their sizes must match.
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
|
||||
_Array<_Tp> __b, size_t __s2)
|
||||
{ __valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
|
||||
|
||||
|
||||
// Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
|
||||
_Array<_Tp> __b, size_t __n)
|
||||
{ __valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
|
||||
|
||||
// Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
|
||||
_Array<size_t> __i)
|
||||
{ __valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
|
||||
|
||||
// Copy the __n first elements of an indexed array __src[<__i>] into
|
||||
// another indexed array __dst[<__j>].
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
|
||||
_Array<_Tp> __dst, _Array<size_t> __j)
|
||||
{
|
||||
__valarray_copy(__src._M_data, __n, __i._M_data,
|
||||
__dst._M_data, __j._M_data);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (size_t __n)
|
||||
: _M_data(__valarray_get_storage<_Tp>(__n))
|
||||
{ __valarray_default_construct(_M_data, _M_data + __n); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
|
||||
: _M_data (__v._M_data) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
|
||||
: _M_data(__valarray_get_storage<_Tp>(__s))
|
||||
{ __valarray_copy_construct(__b, __s, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
_Array<_Tp>::begin () const
|
||||
{ return _M_data; }
|
||||
|
||||
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t) \
|
||||
{ \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p) \
|
||||
*__p _Op##= __t; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __p = __a._M_data; \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s, \
|
||||
_Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b, \
|
||||
size_t __n, size_t __s) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __s, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q) \
|
||||
__a._M_data[*__j] _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<size_t> __i) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \
|
||||
*__p _Op##= __b._M_data[*__j]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
size_t* __j (__i._M_data); \
|
||||
for (size_t __k=0; __k<__n; ++__k, ++__j) \
|
||||
__a._M_data[*__j] _Op##= __e[__k]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<bool> __m) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__q; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
bool* ok(__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= __e[__i]; \
|
||||
} \
|
||||
}
|
||||
|
||||
_DEFINE_ARRAY_FUNCTION(+, plus)
|
||||
_DEFINE_ARRAY_FUNCTION(-, minus)
|
||||
_DEFINE_ARRAY_FUNCTION(*, multiplies)
|
||||
_DEFINE_ARRAY_FUNCTION(/, divides)
|
||||
_DEFINE_ARRAY_FUNCTION(%, modulus)
|
||||
_DEFINE_ARRAY_FUNCTION(^, xor)
|
||||
_DEFINE_ARRAY_FUNCTION(|, or)
|
||||
_DEFINE_ARRAY_FUNCTION(&, and)
|
||||
_DEFINE_ARRAY_FUNCTION(<<, shift_left)
|
||||
_DEFINE_ARRAY_FUNCTION(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_FUNCTION
|
||||
|
||||
} // std::
|
||||
|
||||
#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
|
||||
# define export
|
||||
# include <bits/valarray_array.tcc>
|
||||
#endif
|
||||
|
||||
#endif /* _CPP_BITS_ARRAY_H */
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user