Showing preview only (2,471K chars total). Download the full file or copy to clipboard to get everything.
Repository: gatieme/STLSourceAnalysis
Branch: master
Commit: 55ade9a507a7
Files: 535
Total size: 2.3 MB
Directory structure:
gitextract_3mc_7onk/
├── stl-3.3-source/
│ ├── algo.h
│ ├── algobase.h
│ ├── algorithm
│ ├── alloc.h
│ ├── bitset
│ ├── bvector.h
│ ├── char_traits.h
│ ├── concept_checks.h
│ ├── container_concepts.h
│ ├── defalloc.h
│ ├── deque
│ ├── deque.h
│ ├── function.h
│ ├── functional
│ ├── hash_map
│ ├── hash_map.h
│ ├── hash_set
│ ├── hash_set.h
│ ├── hashtable.h
│ ├── heap.h
│ ├── iterator
│ ├── iterator.h
│ ├── limits
│ ├── list
│ ├── list.h
│ ├── map
│ ├── map.h
│ ├── memory
│ ├── multimap.h
│ ├── multiset.h
│ ├── numeric
│ ├── pair.h
│ ├── pthread_alloc
│ ├── pthread_alloc.h
│ ├── queue
│ ├── rope
│ ├── rope.h
│ ├── ropeimpl.h
│ ├── sequence_concepts.h
│ ├── set
│ ├── set.h
│ ├── slist
│ ├── slist.h
│ ├── stack
│ ├── stack.h
│ ├── stdexcept
│ ├── stl-3.3.IAB
│ ├── stl-3.3.IAD
│ ├── stl-3.3.IMB
│ ├── stl-3.3.IMD
│ ├── stl-3.3.PFI
│ ├── stl-3.3.PO
│ ├── stl-3.3.PR
│ ├── stl-3.3.PRI
│ ├── stl-3.3.PS
│ ├── stl-3.3.SearchResults
│ ├── stl-3.3.WK3
│ ├── stl_algo.h
│ ├── stl_algobase.h
│ ├── stl_alloc.h
│ ├── stl_bvector.h
│ ├── stl_config.h
│ ├── stl_construct.h
│ ├── stl_ctraits_fns.h
│ ├── stl_deque.h
│ ├── stl_exception.h
│ ├── stl_function.h
│ ├── stl_hash_fun.h
│ ├── stl_hash_map.h
│ ├── stl_hash_set.h
│ ├── stl_hashtable.h
│ ├── stl_heap.h
│ ├── stl_iterator.h
│ ├── stl_iterator_base.h
│ ├── stl_list.h
│ ├── stl_map.h
│ ├── stl_multimap.h
│ ├── stl_multiset.h
│ ├── stl_numeric.h
│ ├── stl_pair.h
│ ├── stl_queue.h
│ ├── stl_range_errors.h
│ ├── stl_raw_storage_iter.h
│ ├── stl_relops.h
│ ├── stl_rope.h
│ ├── stl_set.h
│ ├── stl_slist.h
│ ├── stl_stack.h
│ ├── stl_string_fwd.h
│ ├── stl_tempbuf.h
│ ├── stl_threads.h
│ ├── stl_tree.h
│ ├── stl_uninitialized.h
│ ├── stl_vector.h
│ ├── string
│ ├── tempbuf.h
│ ├── tree.h
│ ├── type_traits.h
│ ├── utility
│ ├── valarray
│ ├── vector
│ └── vector.h
├── stl-gatieme/
│ ├── 1-stl_config/
│ │ ├── 1config-inclass-init.cpp
│ │ ├── 1config-inclass-init.o
│ │ ├── 1config-operator-overloading.cpp
│ │ ├── 1config-operator-overloading.o
│ │ ├── 1config-template-exp-special.cpp
│ │ ├── 1config-template-exp-special.o
│ │ ├── 1config-temporary-object.cpp
│ │ ├── 1config-temporary-object.o
│ │ ├── 1config.cpp
│ │ ├── 1config.o
│ │ ├── 1config10.cpp
│ │ ├── 1config10.o
│ │ ├── 1config11.cpp
│ │ ├── 1config11.o
│ │ ├── 1config2.cpp
│ │ ├── 1config2.o
│ │ ├── 1config3.cpp
│ │ ├── 1config5.cpp
│ │ ├── 1config5.o
│ │ ├── 1config8.cpp
│ │ ├── 1config8.o
│ │ ├── 1functor.cpp
│ │ ├── 1functor.o
│ │ ├── 1qsort.cpp
│ │ ├── 1qsort.o
│ │ ├── Makefile
│ │ └── stl_config.h
│ ├── 2-defalloc/
│ │ ├── 2jjalloc.h
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── defalloc.h
│ │ ├── simple_jjallocator.h
│ │ ├── stl_alloc.h
│ │ └── test.cpp
│ ├── 3-iterator/
│ │ ├── 3autoptr.cpp
│ │ ├── 3find.cpp
│ │ ├── 3function_template1.cpp
│ │ ├── 3function_template2.cpp
│ │ ├── 3function_template3.cpp
│ │ ├── 3mylist.h
│ │ ├── 3mylist_iter.h
│ │ ├── 3mylist_iter_stl.h
│ │ ├── 3mylist_iter_test.cpp
│ │ ├── 3tag_test.cpp
│ │ ├── 3templatespecial_class.cpp
│ │ ├── 3templatespecial_func.cpp
│ │ ├── 3test_typeid.cpp
│ │ ├── Makefile
│ │ ├── test_auto_ptr.cpp
│ │ ├── test_bad_typeid.cpp
│ │ └── typeinfo.h
│ ├── 4-sequence-containers/
│ │ ├── 4deque_test.cpp
│ │ ├── 4heap_test.cpp
│ │ ├── 4queue_test.cpp
│ │ ├── 4stack_test.cpp
│ │ ├── 4vector_reset.cpp
│ │ └── 4vector_test.cpp
│ ├── Make.defines.freebsd
│ ├── Make.defines.linux
│ ├── Make.defines.macos
│ ├── Make.defines.solaris
│ ├── Makefile
│ └── systype.sh
├── stl侯杰源码/
│ ├── Makefile
│ ├── Makefile.h
│ ├── README
│ ├── algo/
│ │ ├── Makefile
│ │ ├── accu1.cpp
│ │ ├── adjdiff1.cpp
│ │ ├── adjfind1.cpp
│ │ ├── algostuff.hpp
│ │ ├── bounds1.cpp
│ │ ├── bsearch1.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── copy3.cpp
│ │ ├── count1.cpp
│ │ ├── eqrange1.cpp
│ │ ├── equal1.cpp
│ │ ├── fill1.cpp
│ │ ├── find1.cpp
│ │ ├── find2.cpp
│ │ ├── findend1.cpp
│ │ ├── findof1.cpp
│ │ ├── foreach1.cpp
│ │ ├── foreach2.cpp
│ │ ├── foreach3.cpp
│ │ ├── generate.cpp
│ │ ├── heap1.cpp
│ │ ├── imerge1.cpp
│ │ ├── includes.cpp
│ │ ├── inner1.cpp
│ │ ├── lexico1.cpp
│ │ ├── merge1.cpp
│ │ ├── minmax1.cpp
│ │ ├── misma1.cpp
│ │ ├── nth1.cpp
│ │ ├── part1.cpp
│ │ ├── partsum1.cpp
│ │ ├── perm1.cpp
│ │ ├── psort1.cpp
│ │ ├── psort2.cpp
│ │ ├── random1.cpp
│ │ ├── relabs.cpp
│ │ ├── remove1.cpp
│ │ ├── remove2.cpp
│ │ ├── replace1.cpp
│ │ ├── replace2.cpp
│ │ ├── reverse1.cpp
│ │ ├── rotate1.cpp
│ │ ├── rotate2.cpp
│ │ ├── search1.cpp
│ │ ├── search2.cpp
│ │ ├── searchn1.cpp
│ │ ├── setalgos.cpp
│ │ ├── sort1.cpp
│ │ ├── sort2.cpp
│ │ ├── swap1.cpp
│ │ ├── transf1.cpp
│ │ ├── transf2.cpp
│ │ ├── unique1.cpp
│ │ ├── unique2.cpp
│ │ └── unique3.cpp
│ ├── cont/
│ │ ├── Makefile
│ │ ├── Queue.hpp
│ │ ├── Stack.hpp
│ │ ├── array1.cpp
│ │ ├── bitset1.cpp
│ │ ├── bitset2.cpp
│ │ ├── carray.hpp
│ │ ├── carray1.cpp
│ │ ├── countptr.hpp
│ │ ├── deque1.cpp
│ │ ├── list1.cpp
│ │ ├── map1.cpp
│ │ ├── mapcmp.cpp
│ │ ├── mapfind.cpp
│ │ ├── mmap1.cpp
│ │ ├── mset1.cpp
│ │ ├── newkey.hpp
│ │ ├── pqueue1.cpp
│ │ ├── print.hpp
│ │ ├── queue1.cpp
│ │ ├── queue2.cpp
│ │ ├── refsem1.cpp
│ │ ├── set1.cpp
│ │ ├── set2.cpp
│ │ ├── setcmp.cpp
│ │ ├── sortset.cpp
│ │ ├── sortvec.cpp
│ │ ├── stack1.cpp
│ │ ├── stack2.cpp
│ │ └── vector1.cpp
│ ├── fo/
│ │ ├── Makefile
│ │ ├── compose1.cpp
│ │ ├── compose10.hpp
│ │ ├── compose11.hpp
│ │ ├── compose12.hpp
│ │ ├── compose2.cpp
│ │ ├── compose21.hpp
│ │ ├── compose22.hpp
│ │ ├── compose3.cpp
│ │ ├── compose4.cpp
│ │ ├── fopow.hpp
│ │ ├── fopow1.cpp
│ │ ├── foreach3.cpp
│ │ ├── genera1.cpp
│ │ ├── genera2.cpp
│ │ ├── memfun1.cpp
│ │ ├── nullary.hpp
│ │ ├── print.hpp
│ │ ├── removeif.cpp
│ │ └── sort1.cpp
│ ├── i18n/
│ │ ├── Makefile
│ │ ├── loc1.cpp
│ │ ├── loc2.cpp
│ │ └── numget.cpp
│ ├── io/
│ │ ├── Makefile
│ │ ├── cat1.cpp
│ │ ├── cat2.cpp
│ │ ├── charcat1.cpp
│ │ ├── charcat2.cpp
│ │ ├── charset.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── countlines.cpp
│ │ ├── frac1in.hpp
│ │ ├── frac1out.hpp
│ │ ├── frac2in.hpp
│ │ ├── frac2out.hpp
│ │ ├── ignore.hpp
│ │ ├── ignore1.cpp
│ │ ├── ignoreparam.hpp
│ │ ├── ignoreparam1.cpp
│ │ ├── inbuf1.cpp
│ │ ├── inbuf1.hpp
│ │ ├── io1.cpp
│ │ ├── outbuf1.cpp
│ │ ├── outbuf1.hpp
│ │ ├── outbuf1x.cpp
│ │ ├── outbuf1x.hpp
│ │ ├── outbuf2.cpp
│ │ ├── outbuf2.hpp
│ │ ├── outbuf3.cpp
│ │ ├── outbuf3.hpp
│ │ ├── rdbuf1.cpp
│ │ ├── rdbuf2.cpp
│ │ ├── redirect.cpp
│ │ ├── rw1.cpp
│ │ ├── sstr1.cpp
│ │ ├── sum1.cpp
│ │ └── sum2.cpp
│ ├── iter/
│ │ ├── Makefile
│ │ ├── advance1.cpp
│ │ ├── advance2.cpp
│ │ ├── assoiter.cpp
│ │ ├── assoiter.hpp
│ │ ├── backins.cpp
│ │ ├── distance.cpp
│ │ ├── distance.hpp
│ │ ├── frontins.cpp
│ │ ├── inserter.cpp
│ │ ├── istriter.cpp
│ │ ├── itercat.cpp
│ │ ├── ostriter.cpp
│ │ ├── print.hpp
│ │ ├── reviter1.cpp
│ │ ├── reviter2.cpp
│ │ ├── reviter3.cpp
│ │ ├── reviter4.cpp
│ │ └── swap1.cpp
│ ├── memory/
│ │ ├── Makefile
│ │ ├── myalloc.hpp
│ │ └── myalloc1.cpp
│ ├── num/
│ │ ├── Makefile
│ │ ├── complex1.cpp
│ │ ├── complex2.cpp
│ │ ├── gslice1.cpp
│ │ ├── indi1.cpp
│ │ ├── masked1.cpp
│ │ ├── slice1.cpp
│ │ ├── val1.cpp
│ │ └── val2.cpp
│ ├── stl/
│ │ ├── Makefile
│ │ ├── add1.cpp
│ │ ├── algo1.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── copy3.cpp
│ │ ├── deque1.cpp
│ │ ├── find1.cpp
│ │ ├── fo1.cpp
│ │ ├── foreach1.cpp
│ │ ├── foreach2.cpp
│ │ ├── ioiter1.cpp
│ │ ├── iterbug1.cpp
│ │ ├── list1.cpp
│ │ ├── list2.cpp
│ │ ├── map1.cpp
│ │ ├── mmap1.cpp
│ │ ├── prime1.cpp
│ │ ├── print.hpp
│ │ ├── remove1.cpp
│ │ ├── remove2.cpp
│ │ ├── remove3.cpp
│ │ ├── remove4.cpp
│ │ ├── riter1.cpp
│ │ ├── set1.cpp
│ │ ├── sort1.cpp
│ │ ├── transform1.cpp
│ │ └── vector1.cpp
│ ├── string/
│ │ ├── Makefile
│ │ ├── icstring.hpp
│ │ ├── icstring1.cpp
│ │ ├── iter1.cpp
│ │ ├── iter2.cpp
│ │ ├── iter3.cpp
│ │ ├── string1.cpp
│ │ ├── string2.cpp
│ │ └── unique.cpp
│ └── util/
│ ├── Makefile
│ ├── autoptr.hpp
│ ├── autoptr1.cpp
│ ├── autoptr2.cpp
│ ├── defalloc.hpp
│ ├── limits1.cpp
│ └── minmax1.cpp
└── tass-sgi-stl-2.91.57-source/
├── JJHOU.TXT
├── PlotFile.h
├── SFile.h
├── algo.h
├── algobase.h
├── algorithm
├── alloc.h
├── builtinbuf.h
├── bvector.h
├── cassert
├── cctype
├── cerrno
├── cfloat
├── ciso646
├── climits
├── clocale
├── cmath
├── complex
├── complex.h
├── csetjmp
├── csignal
├── cstdarg
├── cstddef
├── cstdio
├── cstdlib
├── cstring
├── ctime
├── cwchar
├── cwctype
├── defalloc.h
├── deque
├── deque.h
├── editbuf.h
├── floatio.h
├── fstream
├── fstream.h
├── function.h
├── functional
├── hash_map
├── hash_map.h
├── hash_set
├── hash_set.h
├── hashtable.h
├── heap.h
├── indstream.h
├── iolibio.h
├── iomanip
├── iomanip.h
├── iosfwd
├── iostdio.h
├── iostream
├── iostream.h
├── iostreamP.h
├── istream.h
├── iterator
├── iterator.h
├── libio.h
├── libioP.h
├── list
├── list.h
├── map
├── map.h
├── memory
├── multimap.h
├── multiset.h
├── numeric
├── ostream.h
├── pair.h
├── parsestream.h
├── pfstream.h
├── procbuf.h
├── pthread_alloc
├── pthread_alloc.h
├── queue
├── rope
├── rope.h
├── ropeimpl.h
├── set
├── set.h
├── sgi-stl-2.91.57-source.IAB
├── sgi-stl-2.91.57-source.IAD
├── sgi-stl-2.91.57-source.IMB
├── sgi-stl-2.91.57-source.IMD
├── sgi-stl-2.91.57-source.PFI
├── sgi-stl-2.91.57-source.PO
├── sgi-stl-2.91.57-source.PR
├── sgi-stl-2.91.57-source.PS
├── sgi-stl-2.91.57-source.WK3
├── slist
├── slist.h
├── stack
├── stack.h
├── std/
│ ├── bastring.cc
│ ├── bastring.h
│ ├── complext.cc
│ ├── complext.h
│ ├── dcomplex.h
│ ├── fcomplex.h
│ ├── ldcomplex.h
│ └── straits.h
├── stdexcept
├── stdiostream.h
├── stl.h
├── stl_algo.h
├── stl_algobase.h
├── stl_alloc.h
├── stl_bvector.h
├── stl_config.h
├── stl_construct.h
├── stl_deque.h
├── stl_function.h
├── stl_hash_fun.h
├── stl_hash_map.h
├── stl_hash_set.h
├── stl_hashtable.h
├── stl_heap.h
├── stl_iterator.h
├── stl_list.h
├── stl_map.h
├── stl_multimap.h
├── stl_multiset.h
├── stl_numeric.h
├── stl_pair.h
├── stl_queue.h
├── stl_raw_storage_iter.h
├── stl_relops.h
├── stl_rope.h
├── stl_set.h
├── stl_slist.h
├── stl_stack.h
├── stl_tempbuf.h
├── stl_tree.h
├── stl_uninitialized.h
├── stl_vector.h
├── stream.h
├── streambuf.h
├── strfile.h
├── string
├── strstream
├── strstream.h
├── tempbuf.h
├── tree.h
├── type_traits.h
├── utility
├── vector
└── vector.h
================================================
FILE CONTENTS
================================================
================================================
FILE: stl-3.3-source/algo.h
================================================
/*
*
* 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 __SGI_STL_ALGO_H
#define __SGI_STL_ALGO_H
#include <algobase.h>
#include <tempbuf.h>
#include <stl_algo.h>
#include <stl_numeric.h>
#ifdef __STL_USE_NAMESPACES
// 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::random_sample;
using __STD::random_sample_n;
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;
using __STD::is_sorted;
using __STD::is_heap;
// 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;
using __STD::power;
using __STD::iota;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_ALGO_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/algobase.h
================================================
/*
*
* 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 __SGI_STL_ALGOBASE_H
#define __SGI_STL_ALGOBASE_H
#ifndef __SGI_STL_PAIR_H
#include <pair.h>
#endif
#ifndef __SGI_STL_ITERATOR_H
#include <iterator.h>
#endif
#ifndef __SGI_STL_INTERNAL_ALGOBASE_H
#include <stl_algobase.h>
#endif
#ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
#include <stl_uninitialized.h>
#endif
#ifdef __STL_USE_NAMESPACES
// 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::copy_n;
using __STD::fill;
using __STD::fill_n;
using __STD::mismatch;
using __STD::equal;
using __STD::lexicographical_compare;
using __STD::lexicographical_compare_3way;
// Names from stl_uninitialized.h
using __STD::uninitialized_copy;
using __STD::uninitialized_copy_n;
using __STD::uninitialized_fill;
using __STD::uninitialized_fill_n;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_ALGOBASE_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/algorithm
================================================
/*
*
* 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 __SGI_STL_ALGORITHM
#define __SGI_STL_ALGORITHM
#include <stl_algobase.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_tempbuf.h>
#include <stl_algo.h>
#endif /* __SGI_STL_ALGORITHM */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/alloc.h
================================================
/*
* 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 __SGI_STL_ALLOC_H
#define __SGI_STL_ALLOC_H
#ifndef __STL_CONFIG_H
#include <stl_config.h>
#endif
#ifndef __SGI_STL_INTERNAL_ALLOC_H
#include <stl_alloc.h>
#endif
#ifdef __STL_USE_NAMESPACES
using __STD::__malloc_alloc_template;
using __STD::malloc_alloc;
using __STD::simple_alloc;
using __STD::debug_alloc;
using __STD::__default_alloc_template;
using __STD::alloc;
using __STD::single_client_alloc;
#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
using __STD::__malloc_alloc_oom_handler;
#endif /* __STL_STATIC_TEMPLATE_MEMBER_BUG */
#ifdef __STL_USE_STD_ALLOCATORS
using __STD::allocator;
#endif /* __STL_USE_STD_ALLOCATORS */
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_ALLOC_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/bitset
================================================
/*
* 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.
*/
#ifndef __SGI_STL_BITSET
#define __SGI_STL_BITSET
// A bitset of size N has N % (sizeof(unsigned long) * CHAR_BIT) unused
// bits. (They are the high- order bits in the highest word.) It is
// a class invariant of class bitset<> that those unused bits are
// always zero.
// Most of the actual code isn't contained in bitset<> itself, but in the
// base class _Base_bitset. The base class works with whole words, not with
// individual bits. This allows us to specialize _Base_bitset for the
// important special case where the bitset is only a single word.
// The C++ standard does not define the precise semantics of operator[].
// In this implementation the const version of operator[] is equivalent
// to test(), except that it does no range checking. The non-const version
// returns a reference to a bit, again without doing any range checking.
#include <stddef.h> // for size_t
#include <string.h> // for memset
#include <string>
#include <stdexcept> // for invalid_argument, out_of_range, overflow_error
#ifdef __STL_USE_NEW_IOSTREAMS
#include <iostream>
#else
#include <iostream.h> // for istream, ostream
#endif
#define __BITS_PER_WORD (CHAR_BIT*sizeof(unsigned long))
#define __BITSET_WORDS(__n) \
((__n) < 1 ? 1 : ((__n) + __BITS_PER_WORD - 1)/__BITS_PER_WORD)
__STL_BEGIN_NAMESPACE
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1209
#endif
// structure to aid in counting bits
template<bool __dummy>
struct _Bit_count {
static unsigned char _S_bit_count[256];
};
// Mapping from 8 bit unsigned integers to the index of the first one
// bit:
template<bool __dummy>
struct _First_one {
static unsigned char _S_first_one[256];
};
//
// Base class: general case.
//
template<size_t _Nw>
struct _Base_bitset {
typedef unsigned long _WordT;
_WordT _M_w[_Nw]; // 0 is the least significant word.
_Base_bitset( void ) { _M_do_reset(); }
_Base_bitset(unsigned long __val) {
_M_do_reset();
_M_w[0] = __val;
}
static size_t _S_whichword( size_t __pos )
{ return __pos / __BITS_PER_WORD; }
static size_t _S_whichbyte( size_t __pos )
{ return (__pos % __BITS_PER_WORD) / CHAR_BIT; }
static size_t _S_whichbit( size_t __pos )
{ return __pos % __BITS_PER_WORD; }
static _WordT _S_maskbit( size_t __pos )
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
_WordT& _M_getword(size_t __pos) { return _M_w[_S_whichword(__pos)]; }
_WordT _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; }
_WordT& _M_hiword() { return _M_w[_Nw - 1]; }
_WordT _M_hiword() const { return _M_w[_Nw - 1]; }
void _M_do_and(const _Base_bitset<_Nw>& __x) {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_M_w[__i] &= __x._M_w[__i];
}
}
void _M_do_or(const _Base_bitset<_Nw>& __x) {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_M_w[__i] |= __x._M_w[__i];
}
}
void _M_do_xor(const _Base_bitset<_Nw>& __x) {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_M_w[__i] ^= __x._M_w[__i];
}
}
void _M_do_left_shift(size_t __shift);
void _M_do_right_shift(size_t __shift);
void _M_do_flip() {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_M_w[__i] = ~_M_w[__i];
}
}
void _M_do_set() {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_M_w[__i] = ~static_cast<_WordT>(0);
}
}
void _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
bool _M_is_equal(const _Base_bitset<_Nw>& __x) const {
for (size_t __i = 0; __i < _Nw; ++__i) {
if (_M_w[__i] != __x._M_w[__i])
return false;
}
return true;
}
bool _M_is_any() const {
for ( size_t __i = 0; __i < _Nw; __i++ ) {
if ( _M_w[__i] != static_cast<_WordT>(0) )
return true;
}
return false;
}
size_t _M_do_count() const {
size_t __result = 0;
const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw);
while ( __byte_ptr < __end_ptr ) {
__result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
__byte_ptr++;
}
return __result;
}
unsigned long _M_do_to_ulong() const;
// find first "on" bit
size_t _M_do_find_first(size_t __not_found) const;
// find the next "on" bit that follows "prev"
size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
};
//
// Definitions of non-inline functions from _Base_bitset.
//
template<size_t _Nw>
void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)
{
if (__shift != 0) {
const size_t __wshift = __shift / __BITS_PER_WORD;
const size_t __offset = __shift % __BITS_PER_WORD;
if (__offset == 0)
for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
_M_w[__n] = _M_w[__n - __wshift];
else {
const size_t __sub_offset = __BITS_PER_WORD - __offset;
for (size_t __n = _Nw - 1; __n > __wshift; --__n)
_M_w[__n] = (_M_w[__n - __wshift] << __offset) |
(_M_w[__n - __wshift - 1] >> __sub_offset);
_M_w[__wshift] = _M_w[0] << __offset;
}
fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
}
}
template<size_t _Nw>
void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
{
if (__shift != 0) {
const size_t __wshift = __shift / __BITS_PER_WORD;
const size_t __offset = __shift % __BITS_PER_WORD;
const size_t __limit = _Nw - __wshift - 1;
if (__offset == 0)
for (size_t __n = 0; __n <= __limit; ++__n)
_M_w[__n] = _M_w[__n + __wshift];
else {
const size_t __sub_offset = __BITS_PER_WORD - __offset;
for (size_t __n = 0; __n < __limit; ++__n)
_M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
(_M_w[__n + __wshift + 1] << __sub_offset);
_M_w[__limit] = _M_w[_Nw-1] >> __offset;
}
fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
}
}
template<size_t _Nw>
unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const
{
for (size_t __i = 1; __i < _Nw; ++__i)
if (_M_w[__i])
__STL_THROW(overflow_error("bitset"));
return _M_w[0];
}
template<size_t _Nw>
size_t _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const
{
for ( size_t __i = 0; __i < _Nw; __i++ ) {
_WordT __thisword = _M_w[__i];
if ( __thisword != static_cast<_WordT>(0) ) {
// find byte within word
for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
unsigned char __this_byte
= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
if ( __this_byte )
return __i*__BITS_PER_WORD + __j*CHAR_BIT +
_First_one<true>::_S_first_one[__this_byte];
__thisword >>= CHAR_BIT;
}
}
}
// not found, so return an indication of failure.
return __not_found;
}
template<size_t _Nw>
size_t
_Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const
{
// make bound inclusive
++__prev;
// check out of bounds
if ( __prev >= _Nw * __BITS_PER_WORD )
return __not_found;
// search first word
size_t __i = _S_whichword(__prev);
_WordT __thisword = _M_w[__i];
// mask off bits below bound
__thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
if ( __thisword != static_cast<_WordT>(0) ) {
// find byte within word
// get first byte into place
__thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
unsigned char __this_byte
= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
if ( __this_byte )
return __i*__BITS_PER_WORD + __j*CHAR_BIT +
_First_one<true>::_S_first_one[__this_byte];
__thisword >>= CHAR_BIT;
}
}
// check subsequent words
__i++;
for ( ; __i < _Nw; __i++ ) {
_WordT __thisword = _M_w[__i];
if ( __thisword != static_cast<_WordT>(0) ) {
// find byte within word
for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
unsigned char __this_byte
= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
if ( __this_byte )
return __i*__BITS_PER_WORD + __j*CHAR_BIT +
_First_one<true>::_S_first_one[__this_byte];
__thisword >>= CHAR_BIT;
}
}
}
// not found, so return an indication of failure.
return __not_found;
} // end _M_do_find_next
// ------------------------------------------------------------
//
// Base class: specialization for a single word.
//
__STL_TEMPLATE_NULL struct _Base_bitset<1> {
typedef unsigned long _WordT;
_WordT _M_w;
_Base_bitset( void ) : _M_w(0) {}
_Base_bitset(unsigned long __val) : _M_w(__val) {}
static size_t _S_whichword( size_t __pos )
{ return __pos / __BITS_PER_WORD; }
static size_t _S_whichbyte( size_t __pos )
{ return (__pos % __BITS_PER_WORD) / CHAR_BIT; }
static size_t _S_whichbit( size_t __pos )
{ return __pos % __BITS_PER_WORD; }
static _WordT _S_maskbit( size_t __pos )
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
_WordT& _M_getword(size_t) { return _M_w; }
_WordT _M_getword(size_t) const { return _M_w; }
_WordT& _M_hiword() { return _M_w; }
_WordT _M_hiword() const { return _M_w; }
void _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }
void _M_do_or(const _Base_bitset<1>& __x) { _M_w |= __x._M_w; }
void _M_do_xor(const _Base_bitset<1>& __x) { _M_w ^= __x._M_w; }
void _M_do_left_shift(size_t __shift) { _M_w <<= __shift; }
void _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
void _M_do_flip() { _M_w = ~_M_w; }
void _M_do_set() { _M_w = ~static_cast<_WordT>(0); }
void _M_do_reset() { _M_w = 0; }
bool _M_is_equal(const _Base_bitset<1>& __x) const
{ return _M_w == __x._M_w; }
bool _M_is_any() const
{ return _M_w != 0; }
size_t _M_do_count() const {
size_t __result = 0;
const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
const unsigned char* __end_ptr
= ((const unsigned char*)&_M_w)+sizeof(_M_w);
while ( __byte_ptr < __end_ptr ) {
__result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
__byte_ptr++;
}
return __result;
}
unsigned long _M_do_to_ulong() const { return _M_w; }
size_t _M_do_find_first(size_t __not_found) const;
// find the next "on" bit that follows "prev"
size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
};
//
// Definitions of non-inline functions from the single-word version of
// _Base_bitset.
//
size_t _Base_bitset<1>::_M_do_find_first(size_t __not_found) const
{
_WordT __thisword = _M_w;
if ( __thisword != static_cast<_WordT>(0) ) {
// find byte within word
for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
unsigned char __this_byte
= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
if ( __this_byte )
return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
__thisword >>= CHAR_BIT;
}
}
// not found, so return a value that indicates failure.
return __not_found;
}
size_t _Base_bitset<1>::_M_do_find_next(size_t __prev, size_t __not_found ) const
{
// make bound inclusive
++__prev;
// check out of bounds
if ( __prev >= __BITS_PER_WORD )
return __not_found;
// search first (and only) word
_WordT __thisword = _M_w;
// mask off bits below bound
__thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
if ( __thisword != static_cast<_WordT>(0) ) {
// find byte within word
// get first byte into place
__thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
unsigned char __this_byte
= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
if ( __this_byte )
return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
__thisword >>= CHAR_BIT;
}
}
// not found, so return a value that indicates failure.
return __not_found;
} // end _M_do_find_next
// ------------------------------------------------------------
// Helper class to zero out the unused high-order bits in the highest word.
template <size_t _Extrabits> struct _Sanitize {
static void _M_do_sanitize(unsigned long& __val)
{ __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); }
};
__STL_TEMPLATE_NULL struct _Sanitize<0> {
static void _M_do_sanitize(unsigned long) {}
};
// ------------------------------------------------------------
// Class bitset.
// _Nb may be any nonzero number of type size_t.
template<size_t _Nb>
class bitset : private _Base_bitset<__BITSET_WORDS(_Nb)>
{
private:
typedef _Base_bitset<__BITSET_WORDS(_Nb)> _Base;
typedef unsigned long _WordT;
private:
void _M_do_sanitize() {
_Sanitize<_Nb%__BITS_PER_WORD>::_M_do_sanitize(this->_M_hiword());
}
public:
// bit reference:
class reference;
friend class reference;
class reference {
friend class bitset;
_WordT *_M_wp;
size_t _M_bpos;
// left undefined
reference();
public:
reference( bitset& __b, size_t __pos ) {
_M_wp = &__b._M_getword(__pos);
_M_bpos = _Base::_S_whichbit(__pos);
}
~reference() {}
// for b[i] = __x;
reference& operator=(bool __x) {
if ( __x )
*_M_wp |= _Base::_S_maskbit(_M_bpos);
else
*_M_wp &= ~_Base::_S_maskbit(_M_bpos);
return *this;
}
// for b[i] = b[__j];
reference& operator=(const reference& __j) {
if ( (*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)) )
*_M_wp |= _Base::_S_maskbit(_M_bpos);
else
*_M_wp &= ~_Base::_S_maskbit(_M_bpos);
return *this;
}
// flips the bit
bool operator~() const
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
// for __x = b[i];
operator bool() const
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
// for b[i].flip();
reference& flip() {
*_M_wp ^= _Base::_S_maskbit(_M_bpos);
return *this;
}
};
// 23.3.5.1 constructors:
bitset() {}
bitset(unsigned long __val) : _Base_bitset<__BITSET_WORDS(_Nb)>(__val)
{ _M_do_sanitize(); }
#ifdef __STL_MEMBER_TEMPLATES
template<class _CharT, class _Traits, class _Alloc>
explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __pos = 0)
: _Base()
{
if (__pos > __s.size())
__STL_THROW(out_of_range("bitset"));
_M_copy_from_string(__s, __pos,
basic_string<_CharT, _Traits, _Alloc>::npos);
}
template<class _CharT, class _Traits, class _Alloc>
bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __pos,
size_t __n)
: _Base()
{
if (__pos > __s.size())
__STL_THROW(out_of_range("bitset"));
_M_copy_from_string(__s, __pos, __n);
}
#else /* __STL_MEMBER_TEMPLATES */
explicit bitset(const basic_string<char>& __s,
size_t __pos = 0,
size_t __n = basic_string<char>::npos)
: _Base()
{
if (__pos > __s.size())
__STL_THROW(out_of_range("bitset"));
_M_copy_from_string(__s, __pos, __n);
}
#endif /* __STL_MEMBER_TEMPLATES */
// 23.3.5.2 bitset operations:
bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) {
this->_M_do_and(__rhs);
return *this;
}
bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) {
this->_M_do_or(__rhs);
return *this;
}
bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) {
this->_M_do_xor(__rhs);
return *this;
}
bitset<_Nb>& operator<<=(size_t __pos) {
this->_M_do_left_shift(__pos);
this->_M_do_sanitize();
return *this;
}
bitset<_Nb>& operator>>=(size_t __pos) {
this->_M_do_right_shift(__pos);
this->_M_do_sanitize();
return *this;
}
//
// Extension:
// Versions of single-bit set, reset, flip, test with no range checking.
//
bitset<_Nb>& _Unchecked_set(size_t __pos) {
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) {
if (__val)
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
else
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>& _Unchecked_reset(size_t __pos) {
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>& _Unchecked_flip(size_t __pos) {
this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
return *this;
}
bool _Unchecked_test(size_t __pos) const {
return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0);
}
// Set, reset, and flip.
bitset<_Nb>& set() {
this->_M_do_set();
this->_M_do_sanitize();
return *this;
}
bitset<_Nb>& set(size_t __pos) {
if (__pos >= _Nb)
__STL_THROW(out_of_range("bitset"));
return _Unchecked_set(__pos);
}
bitset<_Nb>& set(size_t __pos, int __val) {
if (__pos >= _Nb)
__STL_THROW(out_of_range("bitset"));
return _Unchecked_set(__pos, __val);
}
bitset<_Nb>& reset() {
this->_M_do_reset();
return *this;
}
bitset<_Nb>& reset(size_t __pos) {
if (__pos >= _Nb)
__STL_THROW(out_of_range("bitset"));
return _Unchecked_reset(__pos);
}
bitset<_Nb>& flip() {
this->_M_do_flip();
this->_M_do_sanitize();
return *this;
}
bitset<_Nb>& flip(size_t __pos) {
if (__pos >= _Nb)
__STL_THROW(out_of_range("bitset"));
return _Unchecked_flip(__pos);
}
bitset<_Nb> operator~() const {
return bitset<_Nb>(*this).flip();
}
// element access:
//for b[i];
reference operator[](size_t __pos) { return reference(*this,__pos); }
bool operator[](size_t __pos) const { return _Unchecked_test(__pos); }
unsigned long to_ulong() const { return this->_M_do_to_ulong(); }
#if defined(__STL_MEMBER_TEMPLATES) && \
defined(__STL_EXPLICIT_FUNCTION_TMPL_ARGS)
template <class _CharT, class _Traits, class _Alloc>
basic_string<_CharT, _Traits, _Alloc> to_string() const {
basic_string<_CharT, _Traits, _Alloc> __result;
_M_copy_to_string(__result);
return __result;
}
#endif /* member templates and explicit function template args */
// Helper functions for string operations.
#ifdef __STL_MEMBER_TEMPLATES
template<class _CharT, class _Traits, class _Alloc>
void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
size_t,
size_t);
template<class _CharT, class _Traits, class _Alloc>
void _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
#else /* __STL_MEMBER_TEMPLATES */
void _M_copy_from_string(const basic_string<char>&, size_t, size_t);
void _M_copy_to_string(basic_string<char>&) const;
#endif /* __STL_MEMBER_TEMPLATES */
size_t count() const { return this->_M_do_count(); }
size_t size() const { return _Nb; }
bool operator==(const bitset<_Nb>& __rhs) const {
return this->_M_is_equal(__rhs);
}
bool operator!=(const bitset<_Nb>& __rhs) const {
return !this->_M_is_equal(__rhs);
}
bool test(size_t __pos) const {
if (__pos > _Nb)
__STL_THROW(out_of_range("bitset"));
return _Unchecked_test(__pos);
}
bool any() const { return this->_M_is_any(); }
bool none() const { return !this->_M_is_any(); }
bitset<_Nb> operator<<(size_t __pos) const
{ return bitset<_Nb>(*this) <<= __pos; }
bitset<_Nb> operator>>(size_t __pos) const
{ return bitset<_Nb>(*this) >>= __pos; }
//
// EXTENSIONS: bit-find operations. These operations are
// experimental, and are subject to change or removal in future
// versions.
//
// find the index of the first "on" bit
size_t _Find_first() const
{ return this->_M_do_find_first(_Nb); }
// find the index of the next "on" bit after prev
size_t _Find_next( size_t __prev ) const
{ return this->_M_do_find_next(__prev, _Nb); }
};
//
// Definitions of non-inline member functions.
//
#ifdef __STL_MEMBER_TEMPLATES
template <size_t _Nb>
template<class _CharT, class _Traits, class _Alloc>
void bitset<_Nb>
::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
size_t __pos,
size_t __n)
{
reset();
const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos));
for (size_t __i = 0; __i < __nbits; ++__i) {
switch(__s[__pos + __nbits - __i - 1]) {
case '0':
break;
case '1':
set(__i);
break;
default:
__STL_THROW(invalid_argument("bitset"));
}
}
}
template <size_t _Nb>
template <class _CharT, class _Traits, class _Alloc>
void bitset<_Nb>
::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
{
__s.assign(_Nb, '0');
for (size_t __i = 0; __i < _Nb; ++__i)
if (_Unchecked_test(__i))
__s[_Nb - 1 - __i] = '1';
}
#else /* __STL_MEMBER_TEMPLATES */
template <size_t _Nb>
void bitset<_Nb>::_M_copy_from_string(const basic_string<char>& __s,
size_t __pos, size_t __n)
{
reset();
size_t __tmp = _Nb;
const size_t __nbits = min(__tmp, min(__n, __s.size() - __pos));
for (size_t __i = 0; __i < __nbits; ++__i) {
switch(__s[__pos + __nbits - __i - 1]) {
case '0':
break;
case '1':
set(__i);
break;
default:
__STL_THROW(invalid_argument("bitset"));
}
}
}
template <size_t _Nb>
void bitset<_Nb>::_M_copy_to_string(basic_string<char>& __s) const
{
__s.assign(_Nb, '0');
for (size_t __i = 0; __i < _Nb; ++__i)
if (_Unchecked_test(__i))
__s[_Nb - 1 - __i] = '1';
}
#endif /* __STL_MEMBER_TEMPLATES */
// ------------------------------------------------------------
//
// 23.3.5.3 bitset operations:
//
template <size_t _Nb>
inline bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
bitset<_Nb> __result(__x);
__result &= __y;
return __result;
}
template <size_t _Nb>
inline bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
bitset<_Nb> __result(__x);
__result |= __y;
return __result;
}
template <size_t _Nb>
inline bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
bitset<_Nb> __result(__x);
__result ^= __y;
return __result;
}
#ifdef __STL_USE_NEW_IOSTREAMS
template <class _CharT, class _Traits, size_t _Nb>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
{
basic_string<_CharT, _Traits> __tmp;
__tmp.reserve(_Nb);
// Skip whitespace
typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
if (__sentry) {
basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
for (size_t __i = 0; __i < _Nb; ++__i) {
static _Traits::int_type __eof = _Traits::eof();
typename _Traits::int_type __c1 = __buf->sbumpc();
if (_Traits::eq_int_type(__c1, __eof)) {
__is.setstate(ios_base::eofbit);
break;
}
else {
char __c2 = _Traits::to_char_type(__c1);
char __c = __is.narrow(__c2, '*');
if (__c == '0' || __c == '1')
__tmp.push_back(__c);
else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
__is.setstate(ios_base::failbit);
break;
}
}
}
if (__tmp.empty())
__is.setstate(ios_base::failbit);
else
__x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
}
return __is;
}
template <class _CharT, class _Traits, size_t _Nb>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x)
{
basic_string<_CharT, _Traits> __tmp;
__x._M_copy_to_string(__tmp);
return __os << __tmp;
}
#else /* __STL_USE_NEW_IOSTREAMS */
template <size_t _Nb>
istream& operator>>(istream& __is, bitset<_Nb>& __x) {
string __tmp;
__tmp.reserve(_Nb);
if (__is.flags() & ios::skipws) {
char __c;
do
__is.get(__c);
while (__is && isspace(__c));
if (__is)
__is.putback(__c);
}
for (size_t __i = 0; __i < _Nb; ++__i) {
char __c;
__is.get(__c);
if (!__is)
break;
else if (__c != '0' && __c != '1') {
__is.putback(__c);
break;
}
else
__tmp.push_back(__c);
}
if (__tmp.empty())
__is.clear(__is.rdstate() | ios::failbit);
else
__x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
return __is;
}
template <size_t _Nb>
ostream& operator<<(ostream& __os, const bitset<_Nb>& __x) {
string __tmp;
__x._M_copy_to_string(__tmp);
return __os << __tmp;
}
#endif /* __STL_USE_NEW_IOSTREAMS */
// ------------------------------------------------------------
// Lookup tables for find and count operations.
template<bool __dummy>
unsigned char _Bit_count<__dummy>::_S_bit_count[] = {
0, /* 0 */ 1, /* 1 */ 1, /* 2 */ 2, /* 3 */ 1, /* 4 */
2, /* 5 */ 2, /* 6 */ 3, /* 7 */ 1, /* 8 */ 2, /* 9 */
2, /* 10 */ 3, /* 11 */ 2, /* 12 */ 3, /* 13 */ 3, /* 14 */
4, /* 15 */ 1, /* 16 */ 2, /* 17 */ 2, /* 18 */ 3, /* 19 */
2, /* 20 */ 3, /* 21 */ 3, /* 22 */ 4, /* 23 */ 2, /* 24 */
3, /* 25 */ 3, /* 26 */ 4, /* 27 */ 3, /* 28 */ 4, /* 29 */
4, /* 30 */ 5, /* 31 */ 1, /* 32 */ 2, /* 33 */ 2, /* 34 */
3, /* 35 */ 2, /* 36 */ 3, /* 37 */ 3, /* 38 */ 4, /* 39 */
2, /* 40 */ 3, /* 41 */ 3, /* 42 */ 4, /* 43 */ 3, /* 44 */
4, /* 45 */ 4, /* 46 */ 5, /* 47 */ 2, /* 48 */ 3, /* 49 */
3, /* 50 */ 4, /* 51 */ 3, /* 52 */ 4, /* 53 */ 4, /* 54 */
5, /* 55 */ 3, /* 56 */ 4, /* 57 */ 4, /* 58 */ 5, /* 59 */
4, /* 60 */ 5, /* 61 */ 5, /* 62 */ 6, /* 63 */ 1, /* 64 */
2, /* 65 */ 2, /* 66 */ 3, /* 67 */ 2, /* 68 */ 3, /* 69 */
3, /* 70 */ 4, /* 71 */ 2, /* 72 */ 3, /* 73 */ 3, /* 74 */
4, /* 75 */ 3, /* 76 */ 4, /* 77 */ 4, /* 78 */ 5, /* 79 */
2, /* 80 */ 3, /* 81 */ 3, /* 82 */ 4, /* 83 */ 3, /* 84 */
4, /* 85 */ 4, /* 86 */ 5, /* 87 */ 3, /* 88 */ 4, /* 89 */
4, /* 90 */ 5, /* 91 */ 4, /* 92 */ 5, /* 93 */ 5, /* 94 */
6, /* 95 */ 2, /* 96 */ 3, /* 97 */ 3, /* 98 */ 4, /* 99 */
3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */
4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */
5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */
5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */
4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */
6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */
2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */
4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */
3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */
3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */
4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */
5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */
2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */
4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */
4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */
6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */
4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */
5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */
6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */
4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */
3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */
5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */
4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */
6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */
5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */
4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */
5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */
6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */
4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */
6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */
6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */
8 /* 255 */
}; // end _Bit_count
template<bool __dummy>
unsigned char _First_one<__dummy>::_S_first_one[] = {
0, /* 0 */ 0, /* 1 */ 1, /* 2 */ 0, /* 3 */ 2, /* 4 */
0, /* 5 */ 1, /* 6 */ 0, /* 7 */ 3, /* 8 */ 0, /* 9 */
1, /* 10 */ 0, /* 11 */ 2, /* 12 */ 0, /* 13 */ 1, /* 14 */
0, /* 15 */ 4, /* 16 */ 0, /* 17 */ 1, /* 18 */ 0, /* 19 */
2, /* 20 */ 0, /* 21 */ 1, /* 22 */ 0, /* 23 */ 3, /* 24 */
0, /* 25 */ 1, /* 26 */ 0, /* 27 */ 2, /* 28 */ 0, /* 29 */
1, /* 30 */ 0, /* 31 */ 5, /* 32 */ 0, /* 33 */ 1, /* 34 */
0, /* 35 */ 2, /* 36 */ 0, /* 37 */ 1, /* 38 */ 0, /* 39 */
3, /* 40 */ 0, /* 41 */ 1, /* 42 */ 0, /* 43 */ 2, /* 44 */
0, /* 45 */ 1, /* 46 */ 0, /* 47 */ 4, /* 48 */ 0, /* 49 */
1, /* 50 */ 0, /* 51 */ 2, /* 52 */ 0, /* 53 */ 1, /* 54 */
0, /* 55 */ 3, /* 56 */ 0, /* 57 */ 1, /* 58 */ 0, /* 59 */
2, /* 60 */ 0, /* 61 */ 1, /* 62 */ 0, /* 63 */ 6, /* 64 */
0, /* 65 */ 1, /* 66 */ 0, /* 67 */ 2, /* 68 */ 0, /* 69 */
1, /* 70 */ 0, /* 71 */ 3, /* 72 */ 0, /* 73 */ 1, /* 74 */
0, /* 75 */ 2, /* 76 */ 0, /* 77 */ 1, /* 78 */ 0, /* 79 */
4, /* 80 */ 0, /* 81 */ 1, /* 82 */ 0, /* 83 */ 2, /* 84 */
0, /* 85 */ 1, /* 86 */ 0, /* 87 */ 3, /* 88 */ 0, /* 89 */
1, /* 90 */ 0, /* 91 */ 2, /* 92 */ 0, /* 93 */ 1, /* 94 */
0, /* 95 */ 5, /* 96 */ 0, /* 97 */ 1, /* 98 */ 0, /* 99 */
2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */
0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */
1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */
0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */
3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */
0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */
1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */
0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */
2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */
0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */
1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */
0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */
5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */
0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */
1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */
0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */
2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */
0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */
1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */
0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */
3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */
0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */
1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */
0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */
2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */
0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */
1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */
0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */
4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */
0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */
1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */
0, /* 255 */
}; // end _First_one
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1209
#endif
__STL_END_NAMESPACE
#undef __BITS_PER_WORD
#undef __BITSET_WORDS
#endif /* __SGI_STL_BITSET */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/bvector.h
================================================
/*
*
* 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 <stl_range_errors.h>
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
#include <vector.h>
#else
#include <algobase.h>
#include <alloc.h>
#endif
#include <stl_bvector.h>
#ifdef __STL_USE_NAMESPACES
using __STD::bit_vector;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_BVECTOR_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/char_traits.h
================================================
/*
* 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 __SGI_STL_CHAR_TRAITS_H
#define __SGI_STL_CHAR_TRAITS_H
#include <string.h>
#include <wchar.h>
#if defined(__STL_USE_NEW_IOSTREAMS) && !defined(__SGI_STL_IOSFWD)
#include <iosfwd>
#endif /* use new iostreams */
__STL_BEGIN_NAMESPACE
// Class __char_traits_base.
template <class _CharT, class _IntT> class __char_traits_base {
public:
typedef _CharT char_type;
typedef _IntT int_type;
#ifdef __STL_USE_NEW_IOSTREAMS
typedef streamoff off_type;
typedef streampos pos_type;
typedef mbstate_t state_type;
#endif /* __STL_USE_NEW_IOSTREAMS */
static void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; }
static bool eq(const _CharT& __c1, const _CharT& __c2)
{ return __c1 == __c2; }
static bool lt(const _CharT& __c1, const _CharT& __c2)
{ return __c1 < __c2; }
static int compare(const _CharT* __s1, const _CharT* __s2, size_t __n) {
for (size_t __i = 0; __i < __n; ++__i)
if (!eq(__s1[__i], __s2[__i]))
return __s1[__i] < __s2[__i] ? -1 : 1;
return 0;
}
static size_t length(const _CharT* __s) {
const _CharT __nullchar = _CharT();
size_t __i;
for (__i = 0; !eq(__s[__i], __nullchar); ++__i)
{}
return __i;
}
static const _CharT* find(const _CharT* __s, size_t __n, const _CharT& __c)
{
for ( ; __n > 0 ; ++__s, --__n)
if (eq(*__s, __c))
return __s;
return 0;
}
static _CharT* move(_CharT* __s1, const _CharT* __s2, size_t __n) {
memmove(__s1, __s2, __n * sizeof(_CharT));
return __s1;
}
static _CharT* copy(_CharT* __s1, const _CharT* __s2, size_t __n) {
memcpy(__s1, __s2, __n * sizeof(_CharT));
return __s1;
}
static _CharT* assign(_CharT* __s, size_t __n, _CharT __c) {
for (size_t __i = 0; __i < __n; ++__i)
__s[__i] = __c;
return __s;
}
static int_type not_eof(const int_type& __c) {
return !eq_int_type(__c, eof()) ? __c : 0;
}
static char_type to_char_type(const int_type& __c) {
return static_cast<char_type>(__c);
}
static int_type to_int_type(const char_type& __c) {
return static_cast<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>(-1);
}
};
// Generic char_traits class. Note that this class is provided only
// as a base for explicit specialization; it is unlikely to be useful
// as is for any particular user-defined type. In particular, it
// *will not work* for a non-POD type.
template <class _CharT> class char_traits
: public __char_traits_base<_CharT, _CharT>
{};
// Specialization for char.
__STL_TEMPLATE_NULL class char_traits<char>
: public __char_traits_base<char, int>
{
public:
static char_type to_char_type(const int_type& __c) {
return static_cast<char_type>(static_cast<unsigned char>(__c));
}
static int_type to_int_type(const char_type& __c) {
return static_cast<unsigned char>(__c);
}
static int compare(const char* __s1, const char* __s2, size_t __n)
{ return memcmp(__s1, __s2, __n); }
static size_t length(const char* __s) { return strlen(__s); }
static void assign(char& __c1, const char& __c2) { __c1 = __c2; }
static char* assign(char* __s, size_t __n, char __c)
{ memset(__s, __c, __n); return __s; }
};
// Specialization for wchar_t.
__STL_TEMPLATE_NULL class char_traits<wchar_t>
: public __char_traits_base<wchar_t, wint_t>
{};
__STL_END_NAMESPACE
#endif /* __SGI_STL_CHAR_TRAITS_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/concept_checks.h
================================================
/*
* Copyright (c) 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.
*/
#ifndef __CONCEPT_CHECKS_H
#define __CONCEPT_CHECKS_H
/*
Use these macro like assertions, but they assert properties
on types (usually template arguments). In technical terms they
verify whether a type "models" a "concept".
This set of requirements and the terminology used here is derived
from the book "Generic Programming and the STL" by Matt Austern
(Addison Wesley). For further information please consult that
book. The requirements also are intended to match the ANSI/ISO C++
standard.
This file covers the basic concepts and the iterator concepts.
There are several other files that provide the requirements
for the STL containers:
container_concepts.h
sequence_concepts.h
assoc_container_concepts.h
Jeremy Siek, 1999
TO DO:
- some issues with regards to concept classification and mutability
including AssociativeContianer -> ForwardContainer
and SortedAssociativeContainer -> ReversibleContainer
- HashedAssociativeContainer
- Allocator
- Function Object Concepts
*/
#ifndef __STL_USE_CONCEPT_CHECKS
// Some compilers lack the features that are necessary for concept checks.
// On those compilers we define the concept check macros to do nothing.
#define __STL_REQUIRES(__type_var, __concept) do {} while(0)
#define __STL_CLASS_REQUIRES(__type_var, __concept) \
static int __##__type_var##_##__concept
#define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0)
#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
static int __##__type_x##__type_y##_require_same_type
#define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0)
#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
static int __##__func##__ret##_generator_check
#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
static int __##__func##__ret##__arg##_unary_function_check
#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
do {} while(0)
#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
static int __##__func##__ret##__first##__second##_binary_function_check
#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
do {} while(0)
#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
static int __##__opname##__ret##__first##__second##_require_binary_op
#else /* __STL_USE_CONCEPT_CHECKS */
// This macro tests whether the template argument "__type_var"
// satisfies the requirements of "__concept". Here is a list of concepts
// that we know how to check:
// _Allocator
// _Assignable
// _DefaultConstructible
// _EqualityComparable
// _LessThanComparable
// _TrivialIterator
// _InputIterator
// _OutputIterator
// _ForwardIterator
// _BidirectionalIterator
// _RandomAccessIterator
// _Mutable_TrivialIterator
// _Mutable_ForwardIterator
// _Mutable_BidirectionalIterator
// _Mutable_RandomAccessIterator
#define __STL_REQUIRES(__type_var, __concept) \
do { \
void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
::__concept##_requirement_violation; __x = __x; } while (0)
// Use this to check whether type X is convertible to type Y
#define __STL_CONVERTIBLE(__type_x, __type_y) \
do { \
void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
__type_y >::__type_X_is_not_convertible_to_type_Y; \
__x = __x; } while (0)
// Use this to test whether two template arguments are the same type
#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) \
do { \
void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
__type_y >::__type_X_not_same_as_type_Y; \
__x = __x; } while (0)
// function object checks
#define __STL_GENERATOR_CHECK(__func, __ret) \
do { \
__ret (*__x)( __func&) = \
_STL_GENERATOR_ERROR< \
__func, __ret>::__generator_requirement_violation; \
__x = __x; } while (0)
#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
do { \
__ret (*__x)( __func&, const __arg& ) = \
_STL_UNARY_FUNCTION_ERROR< \
__func, __ret, __arg>::__unary_function_requirement_violation; \
__x = __x; } while (0)
#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
do { \
__ret (*__x)( __func&, const __first&, const __second& ) = \
_STL_BINARY_FUNCTION_ERROR< \
__func, __ret, __first, __second>::__binary_function_requirement_violation; \
__x = __x; } while (0)
#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
do { \
__ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
__ret, __first, __second>::__binary_operator_requirement_violation; \
__ret (*__y)( const __first&, const __second& ) = \
_STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
__const_binary_operator_requirement_violation; \
__y = __y; __x = __x; } while (0)
#ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
#define __STL_CLASS_REQUIRES(__type_var, __concept)
#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
#define __STL_CLASS_GENERATOR_CHECK(__func, __ret)
#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)
#else
// Use this macro inside of template classes, where you would
// like to place requirements on the template arguments to the class
// Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
// since the type_var is used to construct identifiers. Instead typedef
// the pointer type, then use the typedef name for the __type_var.
#define __STL_CLASS_REQUIRES(__type_var, __concept) \
typedef void (* __func##__type_var##__concept)( __type_var ); \
template <__func##__type_var##__concept _Tp1> \
struct __dummy_struct_##__type_var##__concept { }; \
static __dummy_struct_##__type_var##__concept< \
__concept##_concept_specification< \
__type_var>::__concept##_requirement_violation> \
__dummy_ptr_##__type_var##__concept
#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
__type_y ); \
template < __func_##__type_x##__type_y##same_type _Tp1> \
struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
static __dummy_struct_##__type_x##__type_y##_same_type< \
_STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \
__dummy_ptr_##__type_x##__type_y##_same_type
#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
template <__f_##__func##__ret##_generator _Tp1> \
struct __dummy_struct_##__func##__ret##_generator { }; \
static __dummy_struct_##__func##__ret##_generator< \
_STL_GENERATOR_ERROR< \
__func, __ret>::__generator_requirement_violation> \
__dummy_ptr_##__func##__ret##_generator
#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
const __arg& ); \
template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
struct __dummy_struct_##__func##__ret##__arg##_unary_check { }; \
static __dummy_struct_##__func##__ret##__arg##_unary_check< \
_STL_UNARY_FUNCTION_ERROR< \
__func, __ret, __arg>::__unary_function_requirement_violation> \
__dummy_ptr_##__func##__ret##__arg##_unary_check
#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
typedef __ret (* __f_##__func##__ret##__first##__second##_binary_check)( __func&, const __first&,\
const __second& ); \
template <__f_##__func##__ret##__first##__second##_binary_check _Tp1> \
struct __dummy_struct_##__func##__ret##__first##__second##_binary_check { }; \
static __dummy_struct_##__func##__ret##__first##__second##_binary_check< \
_STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
__binary_function_requirement_violation> \
__dummy_ptr_##__func##__ret##__first##__second##_binary_check
#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op)(const __first&, \
const __second& ); \
template <__f_##__func##__ret##__first##__second##_binary_op _Tp1> \
struct __dummy_struct_##__func##__ret##__first##__second##_binary_op { }; \
static __dummy_struct_##__func##__ret##__first##__second##_binary_op< \
_STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
__binary_operator_requirement_violation> \
__dummy_ptr_##__func##__ret##__first##__second##_binary_op
#endif
/* helper class for finding non-const version of a type. Need to have
something to assign to etc. when testing constant iterators. */
template <class _Tp>
struct _Mutable_trait {
typedef _Tp _Type;
};
template <class _Tp>
struct _Mutable_trait<const _Tp> {
typedef _Tp _Type;
};
/* helper function for avoiding compiler warnings about unused variables */
template <class _Type>
void __sink_unused_warning(_Type) { }
template <class _TypeX, class _TypeY>
struct _STL_CONVERT_ERROR {
static void
__type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
_TypeY __y = __x;
__sink_unused_warning(__y);
}
};
template <class _Type> struct __check_equal { };
template <class _TypeX, class _TypeY>
struct _STL_SAME_TYPE_ERROR {
static void
__type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
__check_equal<_TypeX> t1 = __check_equal<_TypeY>();
}
};
// Some Functon Object Checks
template <class _Func, class _Ret>
struct _STL_GENERATOR_ERROR {
static _Ret __generator_requirement_violation(_Func& __f) {
return __f();
}
};
template <class _Func>
struct _STL_GENERATOR_ERROR<_Func, void> {
static void __generator_requirement_violation(_Func& __f) {
__f();
}
};
template <class _Func, class _Ret, class _Arg>
struct _STL_UNARY_FUNCTION_ERROR {
static _Ret
__unary_function_requirement_violation(_Func& __f,
const _Arg& __arg) {
return __f(__arg);
}
};
template <class _Func, class _Arg>
struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
static void
__unary_function_requirement_violation(_Func& __f,
const _Arg& __arg) {
__f(__arg);
}
};
template <class _Func, class _Ret, class _First, class _Second>
struct _STL_BINARY_FUNCTION_ERROR {
static _Ret
__binary_function_requirement_violation(_Func& __f,
const _First& __first,
const _Second& __second) {
return __f(__first, __second);
}
};
template <class _Func, class _First, class _Second>
struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
static void
__binary_function_requirement_violation(_Func& __f,
const _First& __first,
const _Second& __second) {
__f(__first, __second);
}
};
#define __STL_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
template <class _Ret, class _First, class _Second> \
struct _STL_BINARY##_NAME##_ERROR { \
static _Ret \
__const_binary_operator_requirement_violation(const _First& __first, \
const _Second& __second) { \
return __first _OP __second; \
} \
static _Ret \
__binary_operator_requirement_violation(_First& __first, \
_Second& __second) { \
return __first _OP __second; \
} \
}
__STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
__STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
__STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
__STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
__STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
__STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
__STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
__STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
__STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
__STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
__STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
// ...
// TODO, add unary operators (prefix and postfix)
/*
The presence of this class is just to trick EDG into displaying
these error messages before any other errors. Without the
classes, the errors in the functions get reported after
other class errors deep inside the library. The name
choice just makes for an eye catching error message :)
*/
struct _STL_ERROR {
template <class _Type>
static _Type
__default_constructor_requirement_violation(_Type) {
return _Type();
}
template <class _Type>
static _Type
__assignment_operator_requirement_violation(_Type __a) {
__a = __a;
return __a;
}
template <class _Type>
static _Type
__copy_constructor_requirement_violation(_Type __a) {
_Type __c(__a);
return __c;
}
template <class _Type>
static _Type
__const_parameter_required_for_copy_constructor(_Type /* __a */,
const _Type& __b) {
_Type __c(__b);
return __c;
}
template <class _Type>
static _Type
__const_parameter_required_for_assignment_operator(_Type __a,
const _Type& __b) {
__a = __b;
return __a;
}
template <class _Type>
static _Type
__less_than_comparable_requirement_violation(_Type __a, _Type __b) {
if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
return __b;
}
template <class _Type>
static _Type
__equality_comparable_requirement_violation(_Type __a, _Type __b) {
if (__a == __b || __a != __b) return __a;
return __b;
}
template <class _Iterator>
static void
__dereference_operator_requirement_violation(_Iterator __i) {
__sink_unused_warning(*__i);
}
template <class _Iterator>
static void
__dereference_operator_and_assignment_requirement_violation(_Iterator __i) {
*__i = *__i;
}
template <class _Iterator>
static void
__preincrement_operator_requirement_violation(_Iterator __i) {
++__i;
}
template <class _Iterator>
static void
__postincrement_operator_requirement_violation(_Iterator __i) {
__i++;
}
template <class _Iterator>
static void
__predecrement_operator_requirement_violation(_Iterator __i) {
--__i;
}
template <class _Iterator>
static void
__postdecrement_operator_requirement_violation(_Iterator __i) {
__i--;
}
template <class _Iterator, class _Type>
static void
__postincrement_operator_and_assignment_requirement_violation(_Iterator __i,
_Type __t) {
*__i++ = __t;
}
template <class _Iterator, class _Distance>
static _Iterator
__iterator_addition_assignment_requirement_violation(_Iterator __i,
_Distance __n) {
__i += __n;
return __i;
}
template <class _Iterator, class _Distance>
static _Iterator
__iterator_addition_requirement_violation(_Iterator __i, _Distance __n) {
__i = __i + __n;
__i = __n + __i;
return __i;
}
template <class _Iterator, class _Distance>
static _Iterator
__iterator_subtraction_assignment_requirement_violation(_Iterator __i,
_Distance __n) {
__i -= __n;
return __i;
}
template <class _Iterator, class _Distance>
static _Iterator
__iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) {
__i = __i - __n;
return __i;
}
template <class _Iterator, class _Distance>
static _Distance
__difference_operator_requirement_violation(_Iterator __i, _Iterator __j,
_Distance __n) {
__n = __i - __j;
return __n;
}
template <class _Exp, class _Type, class _Distance>
static _Type
__element_access_operator_requirement_violation(_Exp __x, _Type*,
_Distance __n) {
return __x[__n];
}
template <class _Exp, class _Type, class _Distance>
static void
__element_assignment_operator_requirement_violation(_Exp __x,
_Type* __t,
_Distance __n) {
__x[__n] = *__t;
}
}; /* _STL_ERROR */
/* Associated Type Requirements */
__STL_BEGIN_NAMESPACE
template <class _Iterator> struct iterator_traits;
__STL_END_NAMESPACE
template <class _Iter>
struct __value_type_type_definition_requirement_violation {
typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
};
template <class _Iter>
struct __difference_type_type_definition_requirement_violation {
typedef typename __STD::iterator_traits<_Iter>::difference_type
difference_type;
};
template <class _Iter>
struct __reference_type_definition_requirement_violation {
typedef typename __STD::iterator_traits<_Iter>::reference reference;
};
template <class _Iter>
struct __pointer_type_definition_requirement_violation {
typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
};
template <class _Iter>
struct __iterator_category_type_definition_requirement_violation {
typedef typename __STD::iterator_traits<_Iter>::iterator_category
iterator_category;
};
/* Assignable Requirements */
template <class _Type>
struct _Assignable_concept_specification {
static void _Assignable_requirement_violation(_Type __a) {
_STL_ERROR::__assignment_operator_requirement_violation(__a);
_STL_ERROR::__copy_constructor_requirement_violation(__a);
_STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a);
_STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a);
}
};
/* DefaultConstructible Requirements */
template <class _Type>
struct _DefaultConstructible_concept_specification {
static void _DefaultConstructible_requirement_violation(_Type __a) {
_STL_ERROR::__default_constructor_requirement_violation(__a);
}
};
/* EqualityComparable Requirements */
template <class _Type>
struct _EqualityComparable_concept_specification {
static void _EqualityComparable_requirement_violation(_Type __a) {
_STL_ERROR::__equality_comparable_requirement_violation(__a, __a);
}
};
/* LessThanComparable Requirements */
template <class _Type>
struct _LessThanComparable_concept_specification {
static void _LessThanComparable_requirement_violation(_Type __a) {
_STL_ERROR::__less_than_comparable_requirement_violation(__a, __a);
}
};
/* TrivialIterator Requirements */
template <class _TrivialIterator>
struct _TrivialIterator_concept_specification {
static void
_TrivialIterator_requirement_violation(_TrivialIterator __i) {
typedef typename
__value_type_type_definition_requirement_violation<_TrivialIterator>::
value_type __T;
// Refinement of Assignable
_Assignable_concept_specification<_TrivialIterator>::
_Assignable_requirement_violation(__i);
// Refinement of DefaultConstructible
_DefaultConstructible_concept_specification<_TrivialIterator>::
_DefaultConstructible_requirement_violation(__i);
// Refinement of EqualityComparable
_EqualityComparable_concept_specification<_TrivialIterator>::
_EqualityComparable_requirement_violation(__i);
// Valid Expressions
_STL_ERROR::__dereference_operator_requirement_violation(__i);
}
};
template <class _TrivialIterator>
struct _Mutable_TrivialIterator_concept_specification {
static void
_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) {
_TrivialIterator_concept_specification<_TrivialIterator>::
_TrivialIterator_requirement_violation(__i);
// Valid Expressions
_STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i);
}
};
/* InputIterator Requirements */
template <class _InputIterator>
struct _InputIterator_concept_specification {
static void
_InputIterator_requirement_violation(_InputIterator __i) {
// Refinement of TrivialIterator
_TrivialIterator_concept_specification<_InputIterator>::
_TrivialIterator_requirement_violation(__i);
// Associated Types
__difference_type_type_definition_requirement_violation<_InputIterator>();
__reference_type_definition_requirement_violation<_InputIterator>();
__pointer_type_definition_requirement_violation<_InputIterator>();
__iterator_category_type_definition_requirement_violation<_InputIterator>();
// Valid Expressions
_STL_ERROR::__preincrement_operator_requirement_violation(__i);
_STL_ERROR::__postincrement_operator_requirement_violation(__i);
}
};
/* OutputIterator Requirements */
template <class _OutputIterator>
struct _OutputIterator_concept_specification {
static void
_OutputIterator_requirement_violation(_OutputIterator __i) {
// Refinement of Assignable
_Assignable_concept_specification<_OutputIterator>::
_Assignable_requirement_violation(__i);
// Associated Types
__iterator_category_type_definition_requirement_violation<_OutputIterator>();
// Valid Expressions
_STL_ERROR::__dereference_operator_requirement_violation(__i);
_STL_ERROR::__preincrement_operator_requirement_violation(__i);
_STL_ERROR::__postincrement_operator_requirement_violation(__i);
_STL_ERROR::
__postincrement_operator_and_assignment_requirement_violation(__i, *__i);
}
};
/* ForwardIterator Requirements */
template <class _ForwardIterator>
struct _ForwardIterator_concept_specification {
static void
_ForwardIterator_requirement_violation(_ForwardIterator __i) {
// Refinement of InputIterator
_InputIterator_concept_specification<_ForwardIterator>::
_InputIterator_requirement_violation(__i);
}
};
template <class _ForwardIterator>
struct _Mutable_ForwardIterator_concept_specification {
static void
_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) {
_ForwardIterator_concept_specification<_ForwardIterator>::
_ForwardIterator_requirement_violation(__i);
// Refinement of OutputIterator
_OutputIterator_concept_specification<_ForwardIterator>::
_OutputIterator_requirement_violation(__i);
}
};
/* BidirectionalIterator Requirements */
template <class _BidirectionalIterator>
struct _BidirectionalIterator_concept_specification {
static void
_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) {
// Refinement of ForwardIterator
_ForwardIterator_concept_specification<_BidirectionalIterator>::
_ForwardIterator_requirement_violation(__i);
// Valid Expressions
_STL_ERROR::__predecrement_operator_requirement_violation(__i);
_STL_ERROR::__postdecrement_operator_requirement_violation(__i);
}
};
template <class _BidirectionalIterator>
struct _Mutable_BidirectionalIterator_concept_specification {
static void
_Mutable_BidirectionalIterator_requirement_violation(
_BidirectionalIterator __i)
{
_BidirectionalIterator_concept_specification<_BidirectionalIterator>::
_BidirectionalIterator_requirement_violation(__i);
// Refinement of mutable_ForwardIterator
_Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>::
_Mutable_ForwardIterator_requirement_violation(__i);
typedef typename
__value_type_type_definition_requirement_violation<
_BidirectionalIterator>::value_type __T;
typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0;
// Valid Expressions
_STL_ERROR::
__postincrement_operator_and_assignment_requirement_violation(__i,
*__tmp_ptr);
}
};
/* RandomAccessIterator Requirements */
template <class _RandAccIter>
struct _RandomAccessIterator_concept_specification {
static void
_RandomAccessIterator_requirement_violation(_RandAccIter __i) {
// Refinement of BidirectionalIterator
_BidirectionalIterator_concept_specification<_RandAccIter>::
_BidirectionalIterator_requirement_violation(__i);
// Refinement of LessThanComparable
_LessThanComparable_concept_specification<_RandAccIter>::
_LessThanComparable_requirement_violation(__i);
typedef typename
__value_type_type_definition_requirement_violation<_RandAccIter>
::value_type
value_type;
typedef typename
__difference_type_type_definition_requirement_violation<_RandAccIter>
::difference_type
_Dist;
typedef typename _Mutable_trait<_Dist>::_Type _MutDist;
// Valid Expressions
_STL_ERROR::__iterator_addition_assignment_requirement_violation(__i,
_MutDist());
_STL_ERROR::__iterator_addition_requirement_violation(__i,
_MutDist());
_STL_ERROR::
__iterator_subtraction_assignment_requirement_violation(__i,
_MutDist());
_STL_ERROR::__iterator_subtraction_requirement_violation(__i,
_MutDist());
_STL_ERROR::__difference_operator_requirement_violation(__i, __i,
_MutDist());
typename _Mutable_trait<value_type>::_Type* __dummy_ptr = 0;
_STL_ERROR::__element_access_operator_requirement_violation(__i,
__dummy_ptr,
_MutDist());
}
};
template <class _RandAccIter>
struct _Mutable_RandomAccessIterator_concept_specification {
static void
_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i)
{
_RandomAccessIterator_concept_specification<_RandAccIter>::
_RandomAccessIterator_requirement_violation(__i);
// Refinement of mutable_BidirectionalIterator
_Mutable_BidirectionalIterator_concept_specification<_RandAccIter>::
_Mutable_BidirectionalIterator_requirement_violation(__i);
typedef typename
__value_type_type_definition_requirement_violation<_RandAccIter>
::value_type
value_type;
typedef typename
__difference_type_type_definition_requirement_violation<_RandAccIter>
::difference_type
_Dist;
typename _Mutable_trait<value_type>::_Type* __tmp_ptr = 0;
// Valid Expressions
_STL_ERROR::__element_assignment_operator_requirement_violation(__i,
__tmp_ptr, _Dist());
}
};
#define __STL_TYPEDEF_REQUIREMENT(__REQUIREMENT) \
template <class Type> \
struct __##__REQUIREMENT##__typedef_requirement_violation { \
typedef typename Type::__REQUIREMENT __REQUIREMENT; \
}
__STL_TYPEDEF_REQUIREMENT(value_type);
__STL_TYPEDEF_REQUIREMENT(difference_type);
__STL_TYPEDEF_REQUIREMENT(size_type);
__STL_TYPEDEF_REQUIREMENT(reference);
__STL_TYPEDEF_REQUIREMENT(const_reference);
__STL_TYPEDEF_REQUIREMENT(pointer);
__STL_TYPEDEF_REQUIREMENT(const_pointer);
template <class _Alloc>
struct _Allocator_concept_specification {
static void
_Allocator_requirement_violation(_Alloc __a) {
// Refinement of DefaultConstructible
_DefaultConstructible_concept_specification<_Alloc>::
_DefaultConstructible_requirement_violation(__a);
// Refinement of EqualityComparable
_EqualityComparable_concept_specification<_Alloc>::
_EqualityComparable_requirement_violation(__a);
// Associated Types
__value_type__typedef_requirement_violation<_Alloc>();
__difference_type__typedef_requirement_violation<_Alloc>();
__size_type__typedef_requirement_violation<_Alloc>();
__reference__typedef_requirement_violation<_Alloc>();
__const_reference__typedef_requirement_violation<_Alloc>();
__pointer__typedef_requirement_violation<_Alloc>();
__const_pointer__typedef_requirement_violation<_Alloc>();
typedef typename _Alloc::value_type _Tp;
//__STL_REQUIRES_SAME_TYPE(typename _Alloc::__STL_TEMPLATE rebind<_Tp>::other,
// _Alloc);
}
};
#endif /* __STL_USE_CONCEPT_CHECKS */
#endif /* __CONCEPT_CHECKS_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/container_concepts.h
================================================
/*
* Copyright (c) 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.
*/
#ifndef __STL_CONTAINER_CONCEPTS_H
#define __STL_CONTAINER_CONCEPTS_H
#include <concept_checks.h>
#ifdef __STL_USE_CONCEPT_CHECKS
// This file covers the following concepts:
// _Container
// _ForwardContainer
// _ReversibleContainer
// _const_ReversibleContainer
// _RandomAccessContainer
//
struct _ERROR_IN_STL_CONTAINER {
/* Container expresssions */
template <class _Container>
static void
__begin_iterator_accessor_requirement_violation(_Container __c) {
__c.begin();
}
template <class _Container>
static void
__const_begin_iterator_accessor_requirement_violation(const _Container& __c) {
__c.begin();
}
template <class _Container>
static void
__end_iterator_accessor_requirement_violation(_Container __c) {
__c.end();
}
template <class _Container>
static void
__const_end_iterator_accessor_requirement_violation(const _Container& __c) {
__c.end();
}
template <class _Container>
static void
__rbegin_iterator_accessor_requirement_violation(_Container __c) {
__c.rbegin();
}
template <class _Container>
static void
__const_rbegin_iterator_accessor_requirement_violation(const _Container& __c) {
__c.rbegin();
}
template <class _Container>
static void
__rend_iterator_accessor_requirement_violation(_Container __c) {
__c.rend();
}
template <class _Container>
static void
__const_rend_iterator_accessor_requirement_violation(const _Container& __c) {
__c.rend();
}
template <class _Container>
static void
__size_function_must_be_const(const _Container& __c) {
__c.size();
}
template <class _Container>
static void
__size_function_requirement_violation(_Container& __c) {
__c.size();
__size_function_must_be_const(__c);
}
template <class _Container>
static void
__max_size_function_must_be_const(const _Container& __c) {
__c.max_size();
}
template <class _Container>
static void
__max_size_function_requirement_violation(_Container& __c) {
__c.max_size();
__max_size_function_must_be_const(__c);
}
template <class _Container>
static void
__empty_function_must_be_const(const _Container& __c) {
__c.empty();
}
template <class _Container>
static void
__empty_function_requirement_violation(_Container& __c) {
__c.empty();
__empty_function_must_be_const(__c);
}
template <class _Container>
static void
__swap_function_requirement_violation(_Container& __c) {
__c.swap(__c);
}
};
__STL_TYPEDEF_REQUIREMENT(iterator);
__STL_TYPEDEF_REQUIREMENT(const_iterator);
/* Containers */
template <class _Container>
struct _Container_concept_specification {
static void
_Container_requirement_violation(_Container __c) {
// Refinement of Assignable
_Assignable_concept_specification<_Container>::_Assignable_requirement_violation(__c);
// Associated Types
__value_type__typedef_requirement_violation<_Container>();
__difference_type__typedef_requirement_violation<_Container>();
__size_type__typedef_requirement_violation<_Container>();
__reference__typedef_requirement_violation<_Container>();
__const_reference__typedef_requirement_violation<_Container>();
__pointer__typedef_requirement_violation<_Container>();
__const_pointer__typedef_requirement_violation<_Container>();
__iterator__typedef_requirement_violation<_Container>();
__const_iterator__typedef_requirement_violation<_Container>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_begin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_end_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__begin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__end_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__size_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__max_size_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__empty_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__swap_function_requirement_violation(__c);
// Requirements on Iterators
typedef typename _Container::iterator iter;
typedef typename _Container::const_iterator const_iter;
_InputIterator_concept_specification<const_iter>::_InputIterator_requirement_violation(const_iter());
_InputIterator_concept_specification<iter>::_InputIterator_requirement_violation(iter());
}
};
template <class _ForwardContainer>
struct _ForwardContainer_concept_specification {
static void
_ForwardContainer_requirement_violation(_ForwardContainer __c) {
// Refinement of Container
_Container_concept_specification<_ForwardContainer>::_Container_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ForwardContainer::iterator iter;
typedef typename _ForwardContainer::const_iterator const_iter;
_ForwardIterator_concept_specification<const_iter>::_ForwardIterator_requirement_violation(const_iter());
_Mutable_ForwardIterator_concept_specification<iter>::_Mutable_ForwardIterator_requirement_violation(iter());
}
};
__STL_TYPEDEF_REQUIREMENT(reverse_iterator);
__STL_TYPEDEF_REQUIREMENT(const_reverse_iterator);
template <class _ReversibleContainer>
struct _ReversibleContainer_concept_specification {
static void
_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
// Refinement of ForwardContainer
_ForwardContainer_concept_specification<_ReversibleContainer>::_ForwardContainer_requirement_violation(__c);
// Associated types
__reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
__const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ReversibleContainer::iterator iter;
typedef typename _ReversibleContainer::const_iterator const_iter;
_BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
_Mutable_BidirectionalIterator_concept_specification<iter>::_Mutable_BidirectionalIterator_requirement_violation(iter());
}
};
template <class _ReversibleContainer>
struct _const_ReversibleContainer_concept_specification {
static void
_const_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
// Refinement of Container (JGS, not ForwardContainer)
_Container_concept_specification<_ReversibleContainer>::_Container_requirement_violation(__c);
// Associated types
__reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
__const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ReversibleContainer::iterator iter;
typedef typename _ReversibleContainer::const_iterator const_iter;
// This line won't compile on gcc 2.91 due to a compiler bug.
#if !(__GNUC__ == 2 && __GNUC_MINOR__ == 91)
__BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
#endif
}
};
template <class _RandomAccessContainer>
struct _RandomAccessContainer_concept_specification {
static void
_RandomAccessContainer_requirement_violation(_RandomAccessContainer __c) {
// Refinement of ReversibleContainer
_ReversibleContainer_concept_specification<_RandomAccessContainer>::_ReversibleContainer_requirement_violation(__c);
// Valid Expressions
typedef typename _RandomAccessContainer::value_type __T;
typedef typename _RandomAccessContainer::difference_type _Dist;
typedef typename _Mutable_trait<__T>::_Type Type;
typedef Type* _TypePtr;
typedef typename _Mutable_trait<_Dist>::_Type Dist;
_STL_ERROR::__element_access_operator_requirement_violation(__c,
_TypePtr(),
Dist());
// Requirements on Iterators
typedef typename _RandomAccessContainer::iterator iter;
typedef typename _RandomAccessContainer::const_iterator const_iter;
_RandomAccessIterator_concept_specification<const_iter>::_RandomAccessIterator_requirement_violation(const_iter());
_Mutable_RandomAccessIterator_concept_specification<iter>::_Mutable_RandomAccessIterator_requirement_violation(iter());
}
};
#endif /* if __STL_USE_CONCEPT_CHECKS */
#endif /* __STL_CONTAINER_CONCEPTS_H */
================================================
FILE: stl-3.3-source/defalloc.h
================================================
/*
*
* 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 DEFALLOC_H
#define DEFALLOC_H
#include <new.h>
#include <stddef.h>
#include <stdlib.h>
#include <limits.h>
#include <iostream.h>
#include <algobase.h>
template <class T>
inline T* allocate(ptrdiff_t size, T*) {
set_new_handler(0);
T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
if (tmp == 0) {
cerr << "out of memory" << endl;
exit(1);
}
return tmp;
}
template <class T>
inline void deallocate(T* buffer) {
::operator delete(buffer);
}
template <class T>
class allocator {
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& 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(T)));
}
size_type max_size() const {
return max(size_type(1), size_type(UINT_MAX/sizeof(T)));
}
};
class allocator<void> {
public:
typedef void* pointer;
};
#endif
================================================
FILE: stl-3.3-source/deque
================================================
/*
*
* 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 __SGI_STL_DEQUE
#define __SGI_STL_DEQUE
#include <stl_range_errors.h>
#include <stl_algobase.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_deque.h>
#endif /* __SGI_STL_DEQUE */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/deque.h
================================================
/*
*
* 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 __SGI_STL_DEQUE_H
#define __SGI_STL_DEQUE_H
#include <stl_range_errors.h>
#include <algobase.h>
#include <alloc.h>
#include <stl_deque.h>
#ifdef __STL_USE_NAMESPACES
using __STD::deque;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_DEQUE_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/function.h
================================================
/*
*
* 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 __SGI_STL_FUNCTION_H
#define __SGI_STL_FUNCTION_H
#ifndef __STL_CONFIG_H
#include <stl_config.h>
#endif
#ifndef __SGI_STL_INTERNAL_RELOPS
#include <stl_relops.h>
#endif
#include <stddef.h>
#ifndef __SGI_STL_INTERNAL_FUNCTION_H
#include <stl_function.h>
#endif
#ifdef __STL_USE_NAMESPACE_FOR_RELOPS
// Names from stl_relops.h
using __STD_RELOPS::operator!=;
using __STD_RELOPS::operator>;
using __STD_RELOPS::operator<=;
using __STD_RELOPS::operator>=;
#endif /* __STL_USE_NAMESPACE_FOR_RELOPS */
#ifdef __STL_USE_NAMESPACES
// 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::identity_element;
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::unary_compose;
using __STD::binary_compose;
using __STD::compose1;
using __STD::compose2;
using __STD::pointer_to_unary_function;
using __STD::pointer_to_binary_function;
using __STD::ptr_fun;
using __STD::identity;
using __STD::select1st;
using __STD::select2nd;
using __STD::project1st;
using __STD::project2nd;
using __STD::constant_void_fun;
using __STD::constant_unary_fun;
using __STD::constant_binary_fun;
using __STD::constant0;
using __STD::constant1;
using __STD::constant2;
using __STD::subtractive_rng;
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;
using __STD::mem_fun1;
using __STD::mem_fun1_ref;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_FUNCTION_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/functional
================================================
/*
* 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 __SGI_STL_FUNCTIONAL
#define __SGI_STL_FUNCTIONAL
#include <stl_config.h>
#include <stddef.h>
#include <stl_function.h>
#endif /* __SGI_STL_FUNCTIONAL */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/hash_map
================================================
/*
* 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 __SGI_STL_HASH_MAP
#define __SGI_STL_HASH_MAP
#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
#include <stl_hashtable.h>
#endif
#include <stl_hash_map.h>
#endif /* __SGI_STL_HASH_MAP */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/hash_map.h
================================================
/*
* 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 __SGI_STL_HASH_MAP_H
#define __SGI_STL_HASH_MAP_H
#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
#include <stl_hashtable.h>
#endif
#include <algobase.h>
#include <stl_hash_map.h>
#ifdef __STL_USE_NAMESPACES
using __STD::hash;
using __STD::hashtable;
using __STD::hash_map;
using __STD::hash_multimap;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_HASH_MAP_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/hash_set
================================================
/*
* 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 __SGI_STL_HASH_SET
#define __SGI_STL_HASH_SET
#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
#include <stl_hashtable.h>
#endif
#include <stl_hash_set.h>
#endif /* __SGI_STL_HASH_SET */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/hash_set.h
================================================
/*
* 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 __SGI_STL_HASH_SET_H
#define __SGI_STL_HASH_SET_H
#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
#include <stl_hashtable.h>
#endif
#include <algobase.h>
#include <stl_hash_set.h>
#ifdef __STL_USE_NAMESPACES
using __STD::hash;
using __STD::hashtable;
using __STD::hash_set;
using __STD::hash_multiset;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_HASH_SET_H */
================================================
FILE: stl-3.3-source/hashtable.h
================================================
/*
* 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 __SGI_STL_HASHTABLE_H
#define __SGI_STL_HASHTABLE_H
#include <stl_hashtable.h>
#include <algo.h>
#include <alloc.h>
#include <vector.h>
#ifdef __STL_USE_NAMESPACES
using __STD::hash;
using __STD::hashtable;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_HASHTABLE_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/heap.h
================================================
/*
*
* 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 __SGI_STL_HEAP_H
#define __SGI_STL_HEAP_H
#include <stl_config.h>
#include <stl_heap.h>
#ifdef __STL_USE_NAMESPACES
using __STD::push_heap;
using __STD::pop_heap;
using __STD::make_heap;
using __STD::sort_heap;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_HEAP_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/iterator
================================================
/*
*
* 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 __SGI_STL_ITERATOR
#define __SGI_STL_ITERATOR
#include <stl_config.h>
#include <stl_relops.h>
#include <stddef.h>
#ifdef __STL_USE_NEW_IOSTREAMS
#include <iosfwd>
#else /* __STL_USE_NEW_IOSTREAMS */
#include <iostream.h>
#endif /* __STL_USE_NEW_IOSTREAMS */
#include <stl_iterator_base.h>
#include <stl_iterator.h>
#endif /* __SGI_STL_ITERATOR */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/iterator.h
================================================
/*
*
* 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_ITERATOR_H
#define __SGI_STL_ITERATOR_H
#ifndef __SGI_STL_FUNCTION_H
#include <function.h>
#endif
#include <stddef.h>
#ifdef __STL_USE_NEW_IOSTREAMS
#include <iosfwd>
#else /* __STL_USE_NEW_IOSTREAMS */
#include <iostream.h>
#endif /* __STL_USE_NEW_IOSTREAMS */
#ifndef __SGI_STL_INTERNAL_ITERATOR_BASE_H
#include <stl_iterator_base.h>
#endif
#ifndef __SGI_STL_INTERNAL_ITERATOR_H
#include <stl_iterator.h>
#endif
#ifndef __TYPE_TRAITS_H
#include <type_traits.h>
#endif
#ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
#include <stl_construct.h>
#endif
#ifndef __SGI_STL_INTERNAL_RAW_STORAGE_ITERATOR_H
#include <stl_raw_storage_iter.h>
#endif
#ifdef __STL_USE_NAMESPACES
// 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
using __STD::input_iterator;
using __STD::output_iterator;
using __STD::forward_iterator;
using __STD::bidirectional_iterator;
using __STD::random_access_iterator;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
using __STD::iterator_traits;
#endif
using __STD::iterator_category;
using __STD::distance_type;
using __STD::value_type;
using __STD::distance;
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::reverse_bidirectional_iterator;
using __STD::istream_iterator;
using __STD::ostream_iterator;
// Names from stl_construct.h
using __STD::construct;
using __STD::destroy;
// Names from stl_raw_storage_iter.h
using __STD::raw_storage_iterator;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_ITERATOR_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/limits
================================================
/*
* 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.
*/
/* NOTE: This is not portable code. Parts of numeric_limits<> are
* inherently machine-dependent. At present this file is suitable
* for the MIPS and ia32 architectures.
*/
#ifndef __SGI_CPP_LIMITS
#define __SGI_CPP_LIMITS
#include <limits.h>
#include <float.h>
#include <stl_config.h>
__STL_BEGIN_NAMESPACE
enum float_round_style {
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
enum float_denorm_style {
denorm_indeterminate = -1,
denorm_absent = 0,
denorm_present = 1
};
// The C++ standard (section 18.2.1) requires that some of the members of
// numeric_limits be static const data members that are given constant-
// initializers within the class declaration. On compilers where the
// __STL_STATIC_CONST_INIT_BUG macro is defined, it is impossible to write
// a standard-conforming numeric_limits class.
//
// There are two possible workarounds: either initialize the data
// members outside the class, or change them from data members to
// enums. Neither workaround is satisfactory: the former makes it
// impossible to use the data members in constant-expressions, and the
// latter means they have the wrong type and that it is impossible to
// take their addresses. We choose the former workaround.
#ifdef __STL_STATIC_CONST_INIT_BUG
# define __STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
enum { __mem_name = __mem_value }
#else /* __STL_STATIC_CONST_INIT_BUG */
# define __STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
static const __mem_type __mem_name = __mem_value
#endif /* __STL_STATIC_CONST_INIT_BUG */
// Base class for all specializations of numeric_limits.
template <class __number>
class _Numeric_limits_base {
public:
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false);
static __number min() __STL_NOTHROW { return __number(); }
static __number max() __STL_NOTHROW { return __number(); }
__STL_DECLARE_LIMITS_MEMBER(int, digits, 0);
__STL_DECLARE_LIMITS_MEMBER(int, digits10, 0);
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
__STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);
__STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false);
__STL_DECLARE_LIMITS_MEMBER(int, radix, 0);
static __number epsilon() __STL_NOTHROW { return __number(); }
static __number round_error() __STL_NOTHROW { return __number(); }
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0);
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0);
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0);
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0);
__STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false);
__STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false);
__STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false);
__STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
has_denorm,
denorm_absent);
__STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
static __number infinity() __STL_NOTHROW { return __number(); }
static __number quiet_NaN() __STL_NOTHROW { return __number(); }
static __number signaling_NaN() __STL_NOTHROW { return __number(); }
static __number denorm_min() __STL_NOTHROW { return __number(); }
__STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false);
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false);
__STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false);
__STL_DECLARE_LIMITS_MEMBER(bool, traps, false);
__STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
__STL_DECLARE_LIMITS_MEMBER(float_round_style,
round_style,
round_toward_zero);
};
#ifdef __STL_STATIC_CONST_INIT_BUG
# define __STL_DEFINE_NUMERIC_BASE_MEMBER(__type, __mem)
#else /* __STL_STATIC_CONST_INIT_BUG */
# define __STL_DEFINE_NUMERIC_BASE_MEMBER(__type, __mem) \
template <class __number> \
const __type _Numeric_limits_base<__number>:: __mem
#endif /* __STL_STATIC_CONST_INIT_BUG */
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_specialized);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, digits);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, digits10);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_signed);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_integer);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_exact);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, radix);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, min_exponent);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, max_exponent);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, min_exponent10);
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, max_exponent10);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_infinity);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_quiet_NaN);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_signaling_NaN);
__STL_DEFINE_NUMERIC_BASE_MEMBER(float_denorm_style, has_denorm);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_denorm_loss);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_iec559);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_bounded);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_modulo);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, traps);
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, tinyness_before);
__STL_DEFINE_NUMERIC_BASE_MEMBER(float_round_style, round_style);
// Base class for integers.
template <class _Int,
_Int __imin, _Int __imax,
int __idigits = -1, bool __ismod = true>
class _Integer_limits : public _Numeric_limits_base<_Int>
{
public:
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
static _Int min() __STL_NOTHROW { return __imin; }
static _Int max() __STL_NOTHROW { return __imax; }
__STL_DECLARE_LIMITS_MEMBER(int,
digits,
(__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
- (__imin == 0 ? 0 : 1)
: __idigits);
__STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);
// log 2 = 0.301029995664...
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0);
__STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);
__STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true);
__STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
__STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, __ismod);
};
#ifdef __STL_STATIC_CONST_INIT_BUG
# define __STL_DEFINE_INTEGER_LIMITS_MEMBER(__type, __mem)
#else /* __STL_STATIC_CONST_INIT_BUG */
# define __STL_DEFINE_INTEGER_LIMITS_MEMBER(__type, __mem) \
template <class _Int, _Int __imin, _Int __imax, int __idig, bool __ismod> \
const __type _Integer_limits<_Int, __imin, __imax, __idig, __ismod>::__mem
#endif /* __STL_STATIC_CONST_INIT_BUG */
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_specialized);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, digits);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, digits10);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_signed);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_integer);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_exact);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, radix);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_bounded);
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_modulo);
// Base class for floating-point numbers.
template <class __number,
int __Digits, int __Digits10,
int __MinExp, int __MaxExp,
int __MinExp10, int __MaxExp10,
bool __IsIEC559,
float_round_style __RoundStyle>
class _Floating_limits : public _Numeric_limits_base<__number>
{
public:
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
__STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits);
__STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10);
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
__STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp);
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp);
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10);
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10);
__STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true);
__STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true);
__STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);
__STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
has_denorm,
denorm_indeterminate);
__STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
__STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559);
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
__STL_DECLARE_LIMITS_MEMBER(bool, traps, true);
__STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
__STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle);
};
#ifdef __STL_STATIC_CONST_INIT_BUG
# define __STL_DEFINE_FLOAT_LIMITS_MEMBER(__type, __mem)
#else /* __STL_STATIC_CONST_INIT_BUG */
# define __STL_DEFINE_FLOAT_LIMITS_MEMBER(__type, __mem) \
template <class __Num, int __Dig, int __Dig10, \
int __MnX, int __MxX, int __MnX10, int __MxX10, \
bool __IsIEEE, float_round_style __Sty> \
const __type _Floating_limits<__Num, __Dig, __Dig10, \
__MnX, __MxX, __MnX10, __MxX10, \
__IsIEEE, __Sty>:: __mem
#endif /* __STL_STATIC_CONST_INIT_BUG */
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_specialized);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, digits);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, digits10);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_signed);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, radix);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, min_exponent);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, max_exponent);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, min_exponent10);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, max_exponent10);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_infinity);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_quiet_NaN);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_signaling_NaN);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(float_denorm_style, has_denorm);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_denorm_loss);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_iec559);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_bounded);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, traps);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, tinyness_before);
__STL_DEFINE_FLOAT_LIMITS_MEMBER(float_round_style, round_style);
#undef __STL_DECLARE_NUMERIC_LIMITS_MEMBER
#undef __STL_DEFINE_NUMERIC_BASE_MEMBER
#undef __STL_DEFINE_INTEGER_LIMITS_MEMBER
#undef __STL_DEFINE_FLOAT_LIMITS_MEMBER
// Class numeric_limits
// The unspecialized class.
template<class _Tp>
class numeric_limits : public _Numeric_limits_base<_Tp> {};
// Specializations for all built-in integral types.
#ifndef __STL_NO_BOOL
__STL_TEMPLATE_NULL
class numeric_limits<bool>
: public _Integer_limits<bool, false, true, 1, false>
{};
#endif /* __STL_NO_BOOL */
__STL_TEMPLATE_NULL
class numeric_limits<char>
: public _Integer_limits<char, CHAR_MIN, CHAR_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<signed char>
: public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<unsigned char>
: public _Integer_limits<unsigned char, 0, UCHAR_MAX>
{};
#ifdef __STL_HAS_WCHAR_T
__STL_TEMPLATE_NULL
class numeric_limits<wchar_t>
: public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
{};
#endif
__STL_TEMPLATE_NULL
class numeric_limits<short>
: public _Integer_limits<short, SHRT_MIN, SHRT_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<unsigned short>
: public _Integer_limits<unsigned short, 0, USHRT_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<int>
: public _Integer_limits<int, INT_MIN, INT_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<unsigned int>
: public _Integer_limits<unsigned int, 0, UINT_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<long>
: public _Integer_limits<long, LONG_MIN, LONG_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<unsigned long>
: public _Integer_limits<unsigned long, 0, ULONG_MAX>
{};
#ifdef __STL_LONG_LONG
// Some compilers have long long, but don't define the
// LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This
// assumes that long long is 64 bits.
#if !defined(LONGLONG_MIN) && !defined(LONGLONG_MAX) \
&& !defined(ULONGLONG_MAX)
#define ULONGLONG_MAX 0xffffffffffffffffLLU
#define LONGLONG_MAX 0x7fffffffffffffffLL
#define LONGLONG_MIN (-LONGLONG_MAX - 1LL)
#endif
__STL_TEMPLATE_NULL
class numeric_limits<long long>
: public _Integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>
{};
__STL_TEMPLATE_NULL
class numeric_limits<unsigned long long>
: public _Integer_limits<unsigned long long, 0, ULONGLONG_MAX>
{};
#endif /* __STL_LONG_LONG */
// Specializations for all built-in floating-point type.
__STL_TEMPLATE_NULL class numeric_limits<float>
: public _Floating_limits<float,
FLT_MANT_DIG, // Binary digits of precision
FLT_DIG, // Decimal digits of precision
FLT_MIN_EXP, // Minimum exponent
FLT_MAX_EXP, // Maximum exponent
FLT_MIN_10_EXP, // Minimum base 10 exponent
FLT_MAX_10_EXP, // Maximum base 10 exponent
true, // conforms to iec559
round_to_nearest>
{
public:
static float min() __STL_NOTHROW { return FLT_MIN; }
static float denorm_min() __STL_NOTHROW { return FLT_MIN; }
static float max() __STL_NOTHROW { return FLT_MAX; }
static float epsilon() __STL_NOTHROW { return FLT_EPSILON; }
static float round_error() __STL_NOTHROW { return 0.5f; } // Units: ulps.
static float infinity() __STL_NOTHROW;
static float quiet_NaN() __STL_NOTHROW;
static float signaling_NaN() __STL_NOTHROW;
};
__STL_TEMPLATE_NULL class numeric_limits<double>
: public _Floating_limits<double,
DBL_MANT_DIG, // Binary digits of precision
DBL_DIG, // Decimal digits of precision
DBL_MIN_EXP, // Minimum exponent
DBL_MAX_EXP, // Maximum exponent
DBL_MIN_10_EXP, // Minimum base 10 exponent
DBL_MAX_10_EXP, // Maximum base 10 exponent
true, // conforms to iec559
round_to_nearest>
{
public:
static double min() __STL_NOTHROW { return DBL_MIN; }
static double denorm_min() __STL_NOTHROW { return DBL_MIN; }
static double max() __STL_NOTHROW { return DBL_MAX; }
static double epsilon() __STL_NOTHROW { return DBL_EPSILON; }
static double round_error() __STL_NOTHROW { return 0.5; } // Units: ulps.
static double infinity() __STL_NOTHROW;
static double quiet_NaN() __STL_NOTHROW;
static double signaling_NaN() __STL_NOTHROW;
};
__STL_TEMPLATE_NULL class numeric_limits<long double>
: public _Floating_limits<long double,
LDBL_MANT_DIG, // Binary digits of precision
LDBL_DIG, // Decimal digits of precision
LDBL_MIN_EXP, // Minimum exponent
LDBL_MAX_EXP, // Maximum exponent
LDBL_MIN_10_EXP,// Minimum base 10 exponent
LDBL_MAX_10_EXP,// Maximum base 10 exponent
false, // Doesn't conform to iec559
round_to_nearest>
{
public:
static long double min() __STL_NOTHROW { return LDBL_MIN; }
static long double denorm_min() __STL_NOTHROW { return LDBL_MIN; }
static long double max() __STL_NOTHROW { return LDBL_MAX; }
static long double epsilon() __STL_NOTHROW { return LDBL_EPSILON; }
static long double round_error() __STL_NOTHROW { return 4; } // Units: ulps.
static long double infinity() __STL_NOTHROW;
static long double quiet_NaN() __STL_NOTHROW;
static long double signaling_NaN() __STL_NOTHROW;
};
// We write special values (Inf and NaN) as bit patterns and
// cast the the appropriate floating-point types.
#if defined(_MIPSEB)
// Big-endian MIPS. float is 32 bits, double 64, long double 128.
#define _Define_float(__f, __h, __l) \
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
static const unsigned short __x[2] = { __h, __l }; \
return *reinterpret_cast<const float*>(__x); }
#define _Define_double(__f, __h, __l) \
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
static const unsigned short __x[4] = { __h, __l }; \
return *reinterpret_cast<const double*>(__x); }
#define _Define_ldouble(__f, __h, __l) \
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
static const unsigned short __x[8] = { __h, __l }; \
return *reinterpret_cast<const long double*>(__x); }
_Define_float(infinity, 0x7f80, 0)
_Define_float(quiet_NaN, 0x7f81, 0)
_Define_float(signaling_NaN, 0x7fc1, 0)
_Define_double(infinity, 0x7ff0, 0)
_Define_double(quiet_NaN, 0x7ff1, 0)
_Define_double(signaling_NaN, 0x7ff9, 0)
_Define_ldouble(infinity, 0x7ff0, 0)
_Define_ldouble(quiet_NaN, 0x7ff1, 0)
_Define_ldouble(signaling_NaN, 0x7ff9, 0)
#elif defined(__i386) || defined(_M_IX86)
// Little-endian ia32. float is 32 bits, double 64, long double 80.
#define _Define_float(__f, __h, __l) \
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
static const unsigned short __x[2] = { __l, __h }; \
return *reinterpret_cast<const float*>(__x); }
#define _Define_double(__f, __h, __l) \
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
static const unsigned short __x[4] = { 0, 0, __l, __h }; \
return *reinterpret_cast<const double*>(__x); }
#define _Define_ldouble(__f, __h, __l) \
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
static const unsigned short __x[5] = { 0, 0, 0, __l, __h }; \
return *reinterpret_cast<const long double*>(__x); }
_Define_float(infinity, 0x7f80, 0)
_Define_float(quiet_NaN, 0x7fa0, 0)
_Define_float(signaling_NaN, 0x7fc0, 0)
_Define_double(infinity, 0x7ff0, 0)
_Define_double(quiet_NaN, 0x7ff4, 0)
_Define_double(signaling_NaN, 0x7ff8, 0)
_Define_ldouble(infinity, 0x7fff, 0x8000)
_Define_ldouble(quiet_NaN, 0x7fff, 0xa000)
_Define_ldouble(signaling_NaN, 0x7fff, 0xc000)
#else
/* This is an architecture we don't know how to handle. Return some
obviously wrong values. */
#define _Define_float(__f) \
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
return 0; }
#define _Define_double(__f) \
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
return 0; }
#define _Define_ldouble(__f) \
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
return 0; }
_Define_float(infinity)
_Define_float(quiet_NaN)
_Define_float(signaling_NaN)
_Define_double(infinity)
_Define_double(quiet_NaN)
_Define_double(signaling_NaN)
_Define_ldouble(infinity)
_Define_ldouble(quiet_NaN)
_Define_ldouble(signaling_NaN)
#endif
#undef _Define_float
#undef _Define_double
#undef _Define_ldouble
__STL_END_NAMESPACE
#endif /* __SGI_CPP_LIMITS */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/list
================================================
/*
*
* 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 __SGI_STL_LIST
#define __SGI_STL_LIST
#include <stl_algobase.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_list.h>
#endif /* __SGI_STL_LIST */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/list.h
================================================
/*
*
* 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 __SGI_STL_LIST_H
#define __SGI_STL_LIST_H
#include <algobase.h>
#include <alloc.h>
#include <stl_list.h>
#ifdef __STL_USE_NAMESPACES
using __STD::list;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_LIST_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/map
================================================
/*
*
* 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 __SGI_STL_MAP
#define __SGI_STL_MAP
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <stl_map.h>
#include <stl_multimap.h>
#endif /* __SGI_STL_MAP */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/map.h
================================================
/*
*
* 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 __SGI_STL_MAP_H
#define __SGI_STL_MAP_H
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <algobase.h>
#include <alloc.h>
#include <stl_map.h>
#ifdef __STL_USE_NAMESPACES
using __STD::rb_tree;
using __STD::map;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_MAP_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/memory
================================================
/*
* 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.
*
*/
#ifndef __SGI_STL_MEMORY
#define __SGI_STL_MEMORY
#include <stl_algobase.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_tempbuf.h>
#include <stl_uninitialized.h>
#include <stl_raw_storage_iter.h>
__STL_BEGIN_NAMESPACE
#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \
defined(__STL_MEMBER_TEMPLATES)
template<class _Tp1> struct auto_ptr_ref {
_Tp1* _M_ptr;
auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
};
#endif
template <class _Tp> class auto_ptr {
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}
auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}
#ifdef __STL_MEMBER_TEMPLATES
template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
: _M_ptr(__a.release()) {}
#endif /* __STL_MEMBER_TEMPLATES */
auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {
if (&__a != this) {
delete _M_ptr;
_M_ptr = __a.release();
}
return *this;
}
#ifdef __STL_MEMBER_TEMPLATES
template <class _Tp1>
auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {
if (__a.get() != this->get()) {
delete _M_ptr;
_M_ptr = __a.release();
}
return *this;
}
#endif /* __STL_MEMBER_TEMPLATES */
// Note: The C++ standard says there is supposed to be an empty throw
// specification here, but omitting it is standard conforming. Its
// presence can be detected only if _Tp::~_Tp() throws, but (17.4.3.6/2)
// this is prohibited.
~auto_ptr() { delete _M_ptr; }
_Tp& operator*() const __STL_NOTHROW {
return *_M_ptr;
}
_Tp* operator->() const __STL_NOTHROW {
return _M_ptr;
}
_Tp* get() const __STL_NOTHROW {
return _M_ptr;
}
_Tp* release() __STL_NOTHROW {
_Tp* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
void reset(_Tp* __p = 0) __STL_NOTHROW {
if (__p != _M_ptr) {
delete _M_ptr;
_M_ptr = __p;
}
}
// According to the C++ standard, these conversions are required. Most
// present-day compilers, however, do not enforce that requirement---and,
// in fact, most present-day compilers do not support the language
// features that these conversions rely on.
#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \
defined(__STL_MEMBER_TEMPLATES)
public:
auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW
: _M_ptr(__ref._M_ptr) {}
auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW {
if (__ref._M_ptr != this->get()) {
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template <class _Tp1> operator auto_ptr_ref<_Tp1>() __STL_NOTHROW
{ return auto_ptr_ref<_Tp1>(this->release()); }
template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW
{ return auto_ptr<_Tp1>(this->release()); }
#endif /* auto ptr conversions && member templates */
};
__STL_END_NAMESPACE
#endif /* __SGI_STL_MEMORY */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/multimap.h
================================================
/*
*
* 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 __SGI_STL_MULTIMAP_H
#define __SGI_STL_MULTIMAP_H
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <algobase.h>
#include <alloc.h>
#include <stl_multimap.h>
#ifdef __STL_USE_NAMESPACES
using __STD::rb_tree;
using __STD::multimap;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_MULTIMAP_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/multiset.h
================================================
/*
*
* 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 __SGI_STL_MULTISET_H
#define __SGI_STL_MULTISET_H
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <algobase.h>
#include <alloc.h>
#include <stl_multiset.h>
#ifdef __STL_USE_NAMESPACES
using __STD::rb_tree;
using __STD::multiset;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_MULTISET_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/numeric
================================================
/*
*
* 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 __SGI_STL_NUMERIC
#define __SGI_STL_NUMERIC
#include <stl_config.h>
#include <stl_relops.h>
#include <stddef.h>
#ifdef __STL_USE_NEW_IOSTREAMS
#include <iostream>
#else /* __STL_USE_NEW_IOSTREAMS */
#include <iostream.h>
#endif /* __STL_USE_NEW_IOSTREAMS */
#include <stl_iterator_base.h>
#include <stl_iterator.h>
#include <stl_function.h>
#include <stl_numeric.h>
#endif /* __SGI_STL_NUMERIC */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/pair.h
================================================
/*
*
* 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 __SGI_STL_PAIR_H
#define __SGI_STL_PAIR_H
#ifndef __STL_CONFIG_H
#include <stl_config.h>
#endif
#ifndef __SGI_STL_INTERNAL_RELOPS
#include <stl_relops.h>
#endif
#ifndef __SGI_STL_INTERNAL_PAIR_H
#include <stl_pair.h>
#endif
#ifdef __STL_USE_NAMESPACES
using __STD::pair;
using __STD::make_pair;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_PAIR_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/pthread_alloc
================================================
/*
* 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_PTHREAD_ALLOC
#define __SGI_STL_PTHREAD_ALLOC
// 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 <errno.h>
#include <stl_config.h>
#include <stl_alloc.h>
#ifndef __RESTRICT
# define __RESTRICT
#endif
#ifndef __STL_NO_BAD_ALLOC
# include <new>
#endif
__STL_BEGIN_NAMESPACE
#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)) {
__THROW_BAD_ALLOC; // defined in stl_alloc.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) {
__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;
#ifdef __STL_USE_STD_ALLOCATORS
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() __STL_NOTHROW {}
pthread_allocator(const pthread_allocator& a) __STL_NOTHROW {}
template <class _OtherType>
pthread_allocator(const pthread_allocator<_OtherType>&)
__STL_NOTHROW {}
~pthread_allocator() __STL_NOTHROW {}
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 __STL_NOTHROW
{ 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;
};
#endif /* __STL_USE_STD_ALLOCATORS */
__STL_END_NAMESPACE
#endif /* __SGI_STL_PTHREAD_ALLOC */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/pthread_alloc.h
================================================
/*
* 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 __SGI_STL_PTHREAD_ALLOC_H
#define __SGI_STL_PTHREAD_ALLOC_H
#include <pthread_alloc>
#ifdef __STL_USE_NAMESPACES
using __STD::_Pthread_alloc_template;
using __STD::pthread_alloc;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_PTHREAD_ALLOC_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/queue
================================================
/*
*
* 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 __SGI_STL_QUEUE
#define __SGI_STL_QUEUE
#include <stl_algobase.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_vector.h>
#include <stl_bvector.h>
#include <stl_heap.h>
#include <stl_deque.h>
#include <stl_function.h>
#include <stl_queue.h>
#endif /* __SGI_STL_QUEUE */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/rope
================================================
/*
* 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 __SGI_STL_ROPE
#define __SGI_STL_ROPE
#include <stl_algobase.h>
#include <stl_tempbuf.h>
#include <stl_algo.h>
#include <stl_function.h>
#include <stl_numeric.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_hash_fun.h>
#include <stl_rope.h>
#endif /* __SGI_STL_ROPE */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/rope.h
================================================
/*
* 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 __SGI_STL_ROPE_H
#define __SGI_STL_ROPE_H
#include <hashtable.h>
#include <stl_rope.h>
#ifdef __STL_USE_NAMESPACES
using __STD::char_producer;
using __STD::sequence_buffer;
using __STD::rope;
using __STD::crope;
using __STD::wrope;
#endif /* __STL_USE_NAMESPACES */
#endif /* __SGI_STL_ROPE_H */
// Local Variables:
// mode:C++
// End:
================================================
FILE: stl-3.3-source/ropeimpl.h
================================================
/*
* 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.
*/
/* NOTE: This is an internal header file, included by other STL headers.
* You should not attempt to use it directly.
*/
# include <stdio.h>
#ifdef __STL_USE_NEW_IOSTREAMS
# include <iostream>
#else /* __STL_USE_NEW_IOSTREAMS */
# include <iostream.h>
#endif /* __STL_USE_NEW_IOSTREAMS */
#ifdef __STL_USE_EXCEPTIONS
# include <stdexcept>
#endif
__STL_BEGIN_NAMESPACE
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#endif
// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
// if necessary. Assumes _M_path_end[leaf_index] and leaf_pos are correct.
// Results in a valid buf_ptr if the iterator can be legitimately
// dereferenced.
template <class _CharT, class _Alloc>
void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf(
_Rope_iterator_base<_CharT,_Alloc>& __x)
{
const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index];
size_t __leaf_pos = __x._M_leaf_pos;
size_t __pos = __x._M_current_pos;
switch(__leaf->_M_tag) {
case _RopeRep::_S_leaf:
__x._M_buf_start =
((_Rope_RopeLeaf<_CharT,_Alloc>*)__leaf)->_M_data;
__x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
__x._M_buf_end = __x._M_buf_start + __leaf->_M_size;
break;
case _RopeRep::_S_function:
case _RopeRep::_S_substringfn:
{
size_t __len = _S_iterator_buf_len;
size_t __buf_start_pos = __leaf_pos;
size_t __leaf_end = __leaf_pos + __leaf->_M_size;
char_producer<_CharT>* __fn =
((_Rope_RopeFunction<_CharT,_Alloc>*)__leaf)->_M_fn;
if (__buf_start_pos + __len <= __pos) {
__buf_start_pos = __pos - __len/4;
if (__buf_start_pos + __len > __leaf_end) {
__buf_start_pos = __leaf_end - __len;
}
}
if (__buf_start_pos + __len > __leaf_end) {
__len = __leaf_end - __buf_start_pos;
}
(*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf);
__x._M_buf_ptr = __x._M_tmp_buf + (__pos - __buf_start_pos);
__x._M_buf_start = __x._M_tmp_buf;
__x._M_buf_end = __x._M_tmp_buf + __len;
}
break;
default:
__stl_assert(0);
}
}
// Set path and buffer inside a rope iterator. We assume that
// pos and root are already set.
template <class _CharT, class _Alloc>
void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache
(_Rope_iterator_base<_CharT,_Alloc>& __x)
{
const _RopeRep* __path[_RopeRep::_S_max_rope_depth+1];
const _RopeRep* __curr_rope;
int __curr_depth = -1; /* index into path */
size_t __curr_start_pos = 0;
size_t __pos = __x._M_current_pos;
unsigned char __dirns = 0; // Bit vector marking right turns in the path
__stl_assert(__pos <= __x._M_root->_M_size);
if (__pos >= __x._M_root->_M_size) {
__x._M_buf_ptr = 0;
return;
}
__curr_rope = __x._M_root;
if (0 != __curr_rope->_M_c_string) {
/* Treat the root as a leaf. */
__x._M_buf_start = __curr_rope->_M_c_string;
__x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size;
__x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
__x._M_path_end[0] = __curr_rope;
__x._M_leaf_index = 0;
__x._M_leaf_pos = 0;
return;
}
for(;;) {
++__curr_depth;
__stl_assert(__curr_depth <= _RopeRep::_S_max_rope_depth);
__path[__curr_depth] = __curr_rope;
switch(__curr_rope->_M_tag) {
case _RopeRep::_S_leaf:
case _RopeRep::_S_function:
case _RopeRep::_S_substringfn:
__x._M_leaf_pos = __curr_start_pos;
goto done;
case _RopeRep::_S_concat:
{
_Rope_RopeConcatenation<_CharT,_Alloc>* __c =
(_Rope_RopeConcatenation<_CharT,_Alloc>*)__curr_rope;
_RopeRep* __left = __c->_M_left;
size_t __left_len = __left->_M_size;
__dirns <<= 1;
if (__pos >= __curr_start_pos + __left_len) {
__dirns |= 1;
__curr_rope = __c->_M_right;
__curr_start_pos += __left_len;
} else {
__curr_rope = __left;
}
}
break;
}
}
done:
// Copy last section of path into _M_path_end.
{
int __i = -1;
int __j = __curr_depth + 1 - _S_path_cache_len;
if (__j < 0) __j = 0;
while (__j <= __curr_depth) {
__x._M_path_end[++__i] = __path[__j++];
}
__x._M_leaf_index = __i;
}
__x._M_path_directions = __dirns;
_S_setbuf(__x);
}
// Specialized version of the above. Assumes that
// the path cache is valid for the previous position.
template <class _CharT, class _Alloc>
void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache_for_incr
(_Rope_iterator_base<_CharT,_Alloc>& __x)
{
int __current_index = __x._M_leaf_index;
const _RopeRep* __current_node = __x._M_path_end[__current_index];
size_t __len = __current_node->_M_size;
size_t __node_start_pos = __x._M_leaf_pos;
unsigned char __dirns = __x._M_path_directions;
_Rope_RopeConcatenation<_CharT,_Alloc>* __c;
__stl_assert(__x._M_current_pos <= __x._M_root->_M_size);
if (__x._M_current_pos - __node_start_pos < __len) {
/* More stuff in this leaf, we just didn't cache it. */
_S_setbuf(__x);
return;
}
__stl_assert(__node_start_pos + __len == __x._M_current_pos);
// node_start_pos is starting position of last_node.
while (--__current_index >= 0) {
if (!(__dirns & 1) /* Path turned left */)
break;
__current_node = __x._M_path_end[__current_index];
__c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
// Otherwise we were in the right child. Thus we should pop
// the concatenation node.
__node_start_pos -= __c->_M_left->_M_size;
__dirns >>= 1;
}
if (__current_index < 0) {
// We underflowed the cache. Punt.
_S_setcache(__x);
return;
}
__current_node = __x._M_path_end[__current_index];
__c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node;
// current_node is a concatenation node. We are positioned on the first
// character in its right child.
// node_start_pos is starting position of current_node.
__node_start_pos += __c->_M_left->_M_size;
__current_node = __c->_M_right;
__x._M_path_end[++__current_index] = __current_node;
__dirns |= 1;
while (_RopeRep::_S_concat == __current_node->_M_tag) {
++__current_index;
if (_S_path_cache_len == __current_index) {
int __i;
for (__i = 0; __i < _S_path_cache_len-1; __i++) {
__x._M_path_end[__i] = __x._M_path_end[__i+1];
}
--__current_index;
}
__current_node =
((_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node)->_M_left;
__x._M_path_end[__current_index] = __current_node;
__dirns <<= 1;
// node_start_pos is unchanged.
}
__x._M_leaf_index = __current_index;
__x._M_leaf_pos = __node_start_pos;
__x._M_path_directions = __dirns;
_S_setbuf(__x);
}
template <class _CharT, class _Alloc>
void _Rope_iterator_base<_CharT,_Alloc>::_M_incr(size_t __n) {
_M_current_pos += __n;
if (0 != _M_buf_ptr) {
size_t __chars_left = _M_buf_end - _M_buf_ptr;
if (__chars_left > __n) {
_M_buf_ptr += __n;
} else if (__chars_left == __n) {
_M_buf_ptr += __n;
_S_setcache_for_incr(*this);
} else {
_M_buf_ptr = 0;
}
}
}
template <class _CharT, class _Alloc>
void _Rope_iterator_base<_CharT,_Alloc>::_M_decr(size_t __n) {
if (0 != _M_buf_ptr) {
size_t __chars_left = _M_buf_ptr - _M_buf_start;
if (__chars_left >= __n) {
_M_buf_ptr -= __n;
} else {
_M_buf_ptr = 0;
}
}
_M_current_pos -= __n;
}
template <class _CharT, class _Alloc>
void _Rope_iterator<_CharT,_Alloc>::_M_check() {
if (_M_root_rope->_M_tree_ptr != _M_root) {
// _Rope was modified. Get things fixed up.
_RopeRep::_S_unref(_M_root);
_M_root = _M_root_rope->_M_tree_ptr;
_RopeRep::_S_ref(_M_root);
_M_buf_ptr = 0;
}
}
template <class _CharT, class _Alloc>
inline
_Rope_const_iterator<_CharT, _Alloc>::_Rope_const_iterator(
const _Rope_iterator<_CharT,_Alloc>& __x)
: _Rope_iterator_base<_CharT,_Alloc>(__x)
{ }
template <class _CharT, class _Alloc>
inline _Rope_iterator<_CharT,_Alloc>::_Rope_iterator(
rope<_CharT,_Alloc>& __r, size_t __pos)
: _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos),
_M_root_rope(&__r)
{
_RopeRep::_S_ref(_M_root);
}
template <class _CharT, class _Alloc>
inline size_t
rope<_CharT,_Alloc>::_S_char_ptr_len(const _CharT* __s)
{
const _CharT* __p = __s;
while (!_S_is0(*__p)) { ++__p; }
return (__p - __s);
}
#ifndef __GC
template <class _CharT, class _Alloc>
inline void _Rope_RopeRep<_CharT,_Alloc>::_M_free_c_string()
{
_CharT* __cstr = _M_c_string;
if (0 != __cstr) {
size_t __size = _M_size + 1;
destroy(__cstr, __cstr + __size);
_Data_deallocate(__cstr, __size);
}
}
template <class _CharT, class _Alloc>
#ifdef __STL_USE_STD_ALLOCATORS
inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
size_t __n,
allocator_type __a)
#else
inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string(_CharT* __s,
size_t __n)
#endif
{
if (!_S_is_basic_char_type((_CharT*)0)) {
destroy(__s, __s + __n);
}
// This has to be a static member, so this gets a bit messy
# ifdef __STL_USE_STD_ALLOCATORS
__a.deallocate(
__s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
# else
_Data_deallocate(
__s, _Rope_RopeLeaf<_CharT,_Alloc>::_S_rounded_up_size(__n));
# endif
}
// There are several reasons for not doing this with virtual destructors
// and a class specific delete operator:
// - A class specific delete operator can't easily get access to
// allocator instances if we need them.
// - Any virtual function would need a 4 or byte vtable pointer;
// this only requires a one byte tag per object.
template <class _CharT, class _Alloc>
void _Rope_RopeRep<_CharT,_Alloc>::_M_free_tree()
{
switch(_M_tag) {
case _S_leaf:
{
_Rope_RopeLeaf<_CharT,_Alloc>* __l
= (_Rope_RopeLeaf<_CharT,_Alloc>*)this;
__l->_Rope_RopeLeaf<_CharT,_Alloc>::~_Rope_RopeLeaf();
_L_deallocate(__l, 1);
break;
}
case _S_concat:
{
_Rope_RopeConcatenation<_CharT,_Alloc>* __c
= (_Rope_RopeConcatenation<_CharT,_Alloc>*)this;
__c->_Rope_RopeConcatenation<_CharT,_Alloc>::
~_Rope_RopeConcatenation();
_C_deallocate(__c, 1);
break;
}
case _S_function:
{
_Rope_RopeFunction<_CharT,_Alloc>* __f
= (_Rope_RopeFunction<_CharT,_Alloc>*)this;
__f->_Rope_RopeFunction<_CharT,_Alloc>::~_Rope_RopeFunction();
_F_deallocate(__f, 1);
break;
}
case _S_substringfn:
{
_Rope_RopeSubstring<_CharT,_Alloc>* __ss =
(_Rope_RopeSubstring<_CharT,_Alloc>*)this;
__ss->_Rope_RopeSubstring<_CharT,_Alloc>::
~_Rope_RopeSubstring();
_S_deallocate(__ss, 1);
break;
}
}
}
#else
template <class _CharT, class _Alloc>
#ifdef __STL_USE_STD_ALLOCATORS
inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
(const _CharT*, size_t, allocator_type)
#else
inline void _Rope_RopeRep<_CharT,_Alloc>::_S_free_string
(const _CharT*, size_t)
#endif
{}
#endif
// Concatenate a C string onto a leaf rope by copying the rope data.
// Used for short ropes.
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeLeaf*
rope<_CharT,_Alloc>::_S_leaf_concat_char_iter
(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
{
size_t __old_len = __r->_M_size;
_CharT* __new_data = (_CharT*)
_Data_allocate(_S_rounded_up_size(__old_len + __len));
_RopeLeaf* __result;
uninitialized_copy_n(__r->_M_data, __old_len, __new_data);
uninitialized_copy_n(__iter, __len, __new_data + __old_len);
_S_cond_store_eos(__new_data[__old_len + __len]);
__STL_TRY {
__result = _S_new_RopeLeaf(__new_data, __old_len + __len,
__r->get_allocator());
}
__STL_UNWIND(_RopeRep::__STL_FREE_STRING(__new_data, __old_len + __len,
__r->get_allocator()));
return __result;
}
#ifndef __GC
// As above, but it's OK to clobber original if refcount is 1
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeLeaf*
rope<_CharT,_Alloc>::_S_destr_leaf_concat_char_iter
(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
{
__stl_assert(__r->_M_ref_count >= 1);
if (__r->_M_ref_count > 1)
return _S_leaf_concat_char_iter(__r, __iter, __len);
size_t __old_len = __r->_M_size;
if (_S_allocated_capacity(__old_len) >= __old_len + __len) {
// The space has been partially initialized for the standard
// character types. But that doesn't matter for those types.
uninitialized_copy_n(__iter, __len, __r->_M_data + __old_len);
if (_S_is_basic_char_type((_CharT*)0)) {
_S_cond_store_eos(__r->_M_data[__old_len + __len]);
__stl_assert(__r->_M_c_string == __r->_M_data);
} else if (__r->_M_c_string != __r->_M_data && 0 != __r->_M_c_string) {
__r->_M_free_c_string();
__r->_M_c_string = 0;
}
__r->_M_size = __old_len + __len;
__stl_assert(__r->_M_ref_count == 1);
__r->_M_ref_count = 2;
return __r;
} else {
_RopeLeaf* __result = _S_leaf_concat_char_iter(__r, __iter, __len);
__stl_assert(__result->_M_ref_count == 1);
return __result;
}
}
#endif
// Assumes left and right are not 0.
// Does not increment (nor decrement on exception) child reference counts.
// Result has ref count 1.
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeRep*
rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right)
{
_RopeConcatenation* __result =
_S_new_RopeConcatenation(__left, __right, __left->get_allocator());
size_t __depth = __result->_M_depth;
# ifdef __STL_USE_STD_ALLOCATORS
__stl_assert(__left->get_allocator() == __right->get_allocator());
# endif
if (__depth > 20 && (__result->_M_size < 1000 ||
__depth > _RopeRep::_S_max_rope_depth)) {
_RopeRep* __balanced;
__STL_TRY {
__balanced = _S_balance(__result);
# ifndef __GC
if (__result != __balanced) {
__stl_assert(1 == __result->_M_ref_count
&& 1 == __balanced->_M_ref_count);
}
# endif
__result->_M_unref_nonnil();
}
__STL_UNWIND((_C_deallocate(__result,1)));
// In case of exception, we need to deallocate
// otherwise dangling result node. But caller
// still owns its children. Thus unref is
// inappropriate.
return __balanced;
} else {
return __result;
}
}
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter
(_RopeRep* __r, const _CharT*__s, size_t __slen)
{
_RopeRep* __result;
if (0 == __slen) {
_S_ref(__r);
return __r;
}
if (0 == __r)
return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
__r->get_allocator());
if (_RopeRep::_S_leaf == __r->_M_tag &&
__r->_M_size + __slen <= _S_copy_max) {
__result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
# ifndef __GC
__stl_assert(1 == __result->_M_ref_count);
# endif
return __result;
}
if (_RopeRep::_S_concat == __r->_M_tag
&& _RopeRep::_S_leaf == ((_RopeConcatenation*)__r)->_M_right->_M_tag) {
_RopeLeaf* __right =
(_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
if (__right->_M_size + __slen <= _S_copy_max) {
_RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left;
_RopeRep* __nright =
_S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen);
__left->_M_ref_nonnil();
__STL_TRY {
__result = _S_tree_concat(__left, __nright);
}
__STL_UNWIND(_S_unref(__left); _S_unref(__nright));
# ifndef __GC
__stl_assert(1 == __result->_M_ref_count);
# endif
return __result;
}
}
_RopeRep* __nright =
__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
__STL_TRY {
__r->_M_ref_nonnil();
__result = _S_tree_concat(__r, __nright);
}
__STL_UNWIND(_S_unref(__r); _S_unref(__nright));
# ifndef __GC
__stl_assert(1 == __result->_M_ref_count);
# endif
return __result;
}
#ifndef __GC
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeRep*
rope<_CharT,_Alloc>::_S_destr_concat_char_iter(
_RopeRep* __r, const _CharT* __s, size_t __slen)
{
_RopeRep* __result;
if (0 == __r)
return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
__r->get_allocator());
size_t __count = __r->_M_ref_count;
size_t __orig_size = __r->_M_size;
__stl_assert(__count >= 1);
if (__count > 1) return _S_concat_char_iter(__r, __s, __slen);
if (0 == __slen) {
__r->_M_ref_count = 2; // One more than before
return __r;
}
if (__orig_size + __slen <= _S_copy_max &&
_RopeRep::_S_leaf == __r->_M_tag) {
__result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
return __result;
}
if (_RopeRep::_S_concat == __r->_M_tag) {
_RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)__r)->_M_right);
if (_RopeRep::_S_leaf == __right->_M_tag
&& __right->_M_size + __slen <= _S_copy_max) {
_RopeRep* __new_right =
_S_destr_leaf_concat_char_iter(__right, __s, __slen);
if (__right == __new_right) {
__stl_assert(__new_right->_M_ref_count == 2);
__new_right->_M_ref_count = 1;
} else {
__stl_assert(__new_right->_M_ref_count >= 1);
__right->_M_unref_nonnil();
}
__stl_assert(__r->_M_ref_count == 1);
__r->_M_ref_count = 2; // One more than before.
((_RopeConcatenation*)__r)->_M_right = __new_right;
__r->_M_size = __orig_size + __slen;
if (0 != __r->_M_c_string) {
__r->_M_free_c_string();
__r->_M_c_string = 0;
}
return __r;
}
}
_RopeRep* __right =
__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
__r->_M_ref_nonnil();
__STL_TRY {
__result = _S_tree_concat(__r, __right);
}
__STL_UNWIND(_S_unref(__r); _S_unref(__right))
__stl_assert(1 == __result->_M_ref_count);
return __result;
}
#endif /* !__GC */
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeRep*
rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right)
{
if (0 == __left) {
_S_ref(__right);
return __right;
}
if (0 == __right) {
__left->_M_ref_nonnil();
return __left;
}
if (_RopeRep::_S_leaf == __right->_M_tag) {
if (_RopeRep::_S_leaf == __left->_M_tag) {
if (__right->_M_size + __left->_M_size <= _S_copy_max) {
return _S_leaf_concat_char_iter((_RopeLeaf*)__left,
((_RopeLeaf*)__right)->_M_data,
__right->_M_size);
}
} else if (_RopeRep::_S_concat == __left->_M_tag
&& _RopeRep::_S_leaf ==
((_RopeConcatenation*)__left)->_M_right->_M_tag) {
_RopeLeaf* __leftright =
(_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right);
if (__leftright->_M_size + __right->_M_size <= _S_copy_max) {
_RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left;
_RopeRep* __rest = _S_leaf_concat_char_iter(__leftright,
((_RopeLeaf*)__right)->_M_data,
__right->_M_size);
__leftleft->_M_ref_nonnil();
__STL_TRY {
return(_S_tree_concat(__leftleft, __rest));
}
__STL_UNWIND(_S_unref(__leftleft); _S_unref(__rest))
}
}
}
__left->_M_ref_nonnil();
__right->_M_ref_nonnil();
__STL_TRY {
return(_S_tree_concat(__left, __right));
}
__STL_UNWIND(_S_unref(__left); _S_unref(__right));
}
template <class _CharT, class _Alloc>
rope<_CharT,_Alloc>::_RopeRep*
rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base,
size_t __start, size_t __endp1)
{
if (0 == __base) return 0;
size_t __len = __base->_M_size;
size_t __adj_endp1;
const size_t __lazy_threshold = 128;
if (__endp1 >= __len) {
if (0 == __start) {
__base->_M_ref_nonnil();
return __base;
} else {
__adj_endp1 = __len;
}
} else {
__adj_endp1 = __endp1;
}
switch(__base->_M_tag) {
case _RopeRep::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__base;
_RopeRep* __left = __c->_M_left;
_RopeRep* __right = __c->_M_right;
size_t __left_len = __left->_M_size;
_RopeRep* __result;
if (__adj_endp1 <= __left_len) {
return _S_substring(__left, __start, __endp1);
} else if (__start >= __left_len) {
return _S_substring(__right, __start - __left_len,
__adj_endp1 - __left_len);
}
_Self_destruct_ptr __left_result(
_S_substring(__left, __start, __left_len));
_Self_destruct_ptr __right_result(
_S_substring(__right, 0, __endp1 - __left_len));
__result = _S_concat(__left_result, __right_result);
# ifndef __GC
__stl_assert(1 == __result->_M_ref_count);
# endif
return __result;
}
case _RopeRep::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__base;
_RopeLeaf* __result;
size_t __result_len;
if (__start >= __adj_endp1) return 0;
__result_len = __adj_endp1 - __start;
if (__result_len > __lazy_threshold) goto lazy;
# ifdef __GC
const _CharT* __section = __l->_M_data + __start;
__result = _S_new_RopeLeaf(__section, __result_len,
__base->get_allocator());
__result->_M_c_string = 0; // Not eos terminated.
# else
// We should sometimes create substring node instead.
__result = __STL_ROPE_FROM_UNOWNED_CHAR_PTR(
__l->_M_data + __start, __result_len,
__base->get_allocator());
# endif
return __result;
}
case _RopeRep::_S_substringfn:
// Avoid introducing multiple layers of substring nodes.
{
_RopeSubstring* __old = (_RopeSubstring*)__base;
size_t __result_len;
if (__start >= __adj_endp1) return 0;
__result_len = __adj_endp1 - __start;
if (__result_len > __lazy_threshold) {
_RopeSubstring* __result =
_S_new_RopeSubstring(__old->_M_base,
__start + __old->_M_start,
__adj_endp1 - __start,
__base->get_allocator());
return __result;
} // *** else fall through: ***
}
case _RopeRep::_S_function:
{
_RopeFunction* __f = (_RopeFunction*)__base;
_CharT* __section;
size_t __result_len;
if (__start >= __adj_endp1) return 0;
__result_len = __adj_endp1 - __start;
if (__result_len > __lazy_threshold) goto lazy;
__section = (_CharT*)
_Data_allocate(_S_rounded_up_size(__result_len));
__STL_TRY {
(*(__f->_M_fn))(__start, __result_len, __section);
}
__STL_UNWIND(_RopeRep::__STL_FREE_STRING(
__section, __result_len, __base->get_allocator()));
_S_cond_store_eos(__section[__result_len]);
return _S_new_RopeLeaf(__section, __result_len,
__base->get_allocator());
}
}
/*NOTREACHED*/
__stl_assert(false);
lazy:
{
// Create substring node.
return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
__base->get_allocator());
}
}
template<class _CharT>
class _Rope_flatten_char_consumer : public _Rope_char_consumer<_CharT> {
private:
_CharT* _M_buf_ptr;
public:
_Rope_flatten_char_consumer(_CharT* __buffer) {
_M_buf_ptr = __buffer;
};
~_Rope_flatten_char_consumer() {}
bool operator() (const _CharT* __leaf, size_t __n) {
uninitialized_copy_n(__leaf, __n, _M_buf_ptr);
_M_buf_ptr += __n;
return true;
}
};
template<class _CharT>
class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> {
private:
_CharT _M_pattern;
public:
size_t _M_count; // Number of nonmatching characters
_Rope_find_char_char_consumer(_CharT __p)
: _M_pattern(__p), _M_count(0) {}
~_Rope_find_char_char_consumer() {}
bool operator() (const _CharT* __leaf, size_t __n) {
size_t __i;
for (__i = 0; __i < __n; __i++) {
if (__leaf[__i] == _M_pattern) {
_M_count += __i; return false;
}
}
_M_count += __n; return true;
}
};
#ifdef __STL_USE_NEW_IOSTREAMS
template<class _CharT, class _Traits>
// Here _CharT is both the stream and rope character type.
#else
template<class _CharT>
// Here _CharT is the rope character type. Unlike in the
// above case, we somewhat handle the case in which it doesn't
// match the stream character type, i.e. char.
#endif
class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> {
private:
# ifdef __STL_USE_NEW_IOSTREAMS
typedef basic_ostream<_CharT,_Traits> _Insert_ostream;
# else
typedef ostream _Insert_ostream;
# endif
_Insert_ostream& _M_o;
public:
_Rope_insert_char_consumer(_Insert_ostream& __writer)
: _M_o(__writer) {};
~_Rope_insert_char_consumer() { };
// Caller is presumed to own the ostream
bool operator() (const _CharT* __leaf, size_t __n);
// Returns true to continue traversal.
};
#ifdef __STL_USE_NEW_IOSTREAMS
template<class _CharT, class _Traits>
bool _Rope_insert_char_consumer<_CharT, _Traits>::operator()
(const _CharT* __leaf, size_t __n)
{
size_t __i;
// We assume that formatting is set up correctly for each element.
for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
return true;
}
#else
template<class _CharT>
bool _Rope_insert_char_consumer<_CharT>::operator()
(const _CharT* __leaf, size_t __n)
{
size_t __i;
// We assume that formatting is set up correctly for each element.
for (__i = 0; __i < __n; __i++) _M_o << __leaf[__i];
return true;
}
__STL_TEMPLATE_NULL
inline bool _Rope_insert_char_consumer<char>::operator()
(const char* __leaf, size_t __n)
{
size_t __i;
for (__i = 0; __i < __n; __i++) _M_o.put(__leaf[__i]);
return true;
}
#endif
template <class _CharT, class _Alloc>
bool rope<_CharT, _Alloc>::_S_apply_to_pieces(
_Rope_char_consumer<_CharT>& __c,
const _RopeRep* __r,
size_t __begin, size_t __end)
{
if (0 == __r) return true;
switch(__r->_M_tag) {
case _RopeRep::_S_concat:
{
_RopeConcatenation* __conc = (_RopeConcatenation*)__r;
_RopeRep* __left = __conc->_M_left;
size_t __left_len = __left->_M_size;
if (__begin < __left_len) {
size_t __left_end = min(__left_len, __end);
if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
return false;
}
if (__end > __left_len) {
_RopeRep* __right = __conc->_M_right;
size_t __right_start = max(__left_len, __begin);
if (!_S_apply_to_pieces(__c, __right,
__right_start - __left_len,
__end - __left_len)) {
return false;
}
}
}
return true;
case _RopeRep::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
return __c(__l->_M_data + __begin, __end - __begin);
}
case _RopeRep::_S_function:
case _RopeRep::_S_substringfn:
{
_RopeFunction* __f = (_RopeFunction*)__r;
size_t __len = __end - __begin;
bool __result;
_CharT* __buffer =
(_CharT*)alloc::allocate(__len * sizeof(_CharT));
__STL_TRY {
(*(__f->_M_fn))(__begin, __len, __buffer);
__result = __c(__buffer, __len);
alloc::deallocate(__buffer, __len * sizeof(_CharT));
}
__STL_UNWIND((alloc::deallocate(__buffer,
__len * sizeof(_CharT))))
return __result;
}
default:
__stl_assert(false);
/*NOTREACHED*/
return false;
}
}
#ifdef __STL_USE_NEW_IOSTREAMS
template<class _CharT, class _Traits>
inline void _Rope_fill(basic_ostream<_CharT, _Traits>& __o, size_t __n)
#else
inline void _Rope_fill(ostream& __o, size_t __n)
#endif
{
char __f = __o.fill();
size_t __i;
for (__i = 0; __i < __n; __i++) __o.put(__f);
}
template <class _CharT> inline bool _Rope_is_simple(_CharT*) { return false; }
inline bool _Rope_is_simple(char*) { return true; }
inline bool _Rope_is_simple(wchar_t*) { return true; }
#ifdef __STL_USE_NEW_IOSTREAMS
template<class _CharT, class _Traits, class _Alloc>
basic_ostream<_CharT, _Traits>& operator<<
(basic_ostream<_CharT, _Traits>& __o,
const rope<_CharT, _Alloc>& __r)
#else
template<class _CharT, class _Alloc>
ostream& operator<< (ostream& __o, const rope<_CharT, _Alloc>& __r)
#endif
{
size_t __w = __o.width();
bool __left = bool(__o.flags() & ios::left);
size_t __pad_len;
size_t __rope_len = __r.size();
# ifdef __STL_USE_NEW_IOSTREAMS
_Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
# else
_Rope_insert_char_consumer<_CharT> __c(__o);
# endif
bool __is_simple = _Rope_is_simple((_CharT*)0);
if (__rope_len < __w) {
__pad_len = __w - __rope_len;
} else {
__pad_len = 0;
}
if (!__is_simple) __o.width(__w/__rope_len);
__STL_TRY {
if (__is_simple && !__left && __pad_len > 0) {
_Rope_fill(__o, __pad_len);
}
__r.apply_to_pieces(0, __r.size(), __c);
if (__is_simple && __left && __pad_len > 0) {
_Rope_fill(__o, __pad_len);
}
if (!__is_simple)
__o.width(__w);
}
__STL_UNWIND(if (!__is_simple) __o.width(__w))
return __o;
}
template <class _CharT, class _Alloc>
_CharT*
rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r,
size_t __start, size_t __len,
_CharT* __buffer)
{
_Rope_flatten_char_consumer<_CharT> __c(__buffer);
_S_apply_to_pieces(__c, __r, __start, __start + __len);
return(__buffer + __len);
}
template <class _CharT, class _Alloc>
size_t
rope<_CharT,_Alloc>::find(_CharT __pattern, size_t __start) const
{
_Rope_find_char_char_consumer<_CharT> __c(__pattern);
_S_apply_to_pieces(__c, _M_tree_ptr, __start, size());
size_type __result_pos = __start + __c._M_count;
# ifndef __STL_OLD_ROPE_SEMANTICS
if (__result_pos == size()) __result_pos = npos;
# endif
return __result_pos;
}
template <class _CharT, class _Alloc>
_CharT*
rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r, _CharT* __buffer)
{
if (0 == __r) return __buffer;
switch(__r->_M_tag) {
case _RopeRep::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__r;
_RopeRep* __left = __c->_M_left;
_RopeRep* __right = __c->_M_right;
_CharT* __rest = _S_flatten(__left, __buffer);
return _S_flatten(__right, __rest);
}
case _RopeRep::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
}
case _RopeRep::_S_function:
case _RopeRep::_S_substringfn:
// We dont yet do anything with substring nodes.
// This needs to be fixed before ropefiles will work well.
{
_RopeFunction* __f = (_RopeFunction*)__r;
(*(__f->_M_fn))(0, __f->_M_size, __buffer);
return __buffer + __f->_M_size;
}
default:
__stl_assert(false);
/*NOTREACHED*/
return 0;
}
}
// This needs work for _CharT != char
template <class _CharT, class _Alloc>
void
rope<_CharT,_Alloc>::_S_dump(_RopeRep* __r, int __indent)
{
for (int __i = 0; __i < __indent; __i++) putchar(' ');
if (0 == __r) {
printf("NULL\n"); return;
}
if (_RopeRep::_S_concat == __r->_M_tag) {
_RopeConcatenation* __c = (_RopeConcatenation*)__r;
_RopeRep* __left = __c->_M_left;
_RopeRep* __right = __c->_M_right;
# ifdef __GC
printf("Concatenation %p (depth = %d, len = %ld, %s balanced)\n",
__r, __r->_M_depth, __
gitextract_3mc_7onk/
├── stl-3.3-source/
│ ├── algo.h
│ ├── algobase.h
│ ├── algorithm
│ ├── alloc.h
│ ├── bitset
│ ├── bvector.h
│ ├── char_traits.h
│ ├── concept_checks.h
│ ├── container_concepts.h
│ ├── defalloc.h
│ ├── deque
│ ├── deque.h
│ ├── function.h
│ ├── functional
│ ├── hash_map
│ ├── hash_map.h
│ ├── hash_set
│ ├── hash_set.h
│ ├── hashtable.h
│ ├── heap.h
│ ├── iterator
│ ├── iterator.h
│ ├── limits
│ ├── list
│ ├── list.h
│ ├── map
│ ├── map.h
│ ├── memory
│ ├── multimap.h
│ ├── multiset.h
│ ├── numeric
│ ├── pair.h
│ ├── pthread_alloc
│ ├── pthread_alloc.h
│ ├── queue
│ ├── rope
│ ├── rope.h
│ ├── ropeimpl.h
│ ├── sequence_concepts.h
│ ├── set
│ ├── set.h
│ ├── slist
│ ├── slist.h
│ ├── stack
│ ├── stack.h
│ ├── stdexcept
│ ├── stl-3.3.IAB
│ ├── stl-3.3.IAD
│ ├── stl-3.3.IMB
│ ├── stl-3.3.IMD
│ ├── stl-3.3.PFI
│ ├── stl-3.3.PO
│ ├── stl-3.3.PR
│ ├── stl-3.3.PRI
│ ├── stl-3.3.PS
│ ├── stl-3.3.SearchResults
│ ├── stl-3.3.WK3
│ ├── stl_algo.h
│ ├── stl_algobase.h
│ ├── stl_alloc.h
│ ├── stl_bvector.h
│ ├── stl_config.h
│ ├── stl_construct.h
│ ├── stl_ctraits_fns.h
│ ├── stl_deque.h
│ ├── stl_exception.h
│ ├── stl_function.h
│ ├── stl_hash_fun.h
│ ├── stl_hash_map.h
│ ├── stl_hash_set.h
│ ├── stl_hashtable.h
│ ├── stl_heap.h
│ ├── stl_iterator.h
│ ├── stl_iterator_base.h
│ ├── stl_list.h
│ ├── stl_map.h
│ ├── stl_multimap.h
│ ├── stl_multiset.h
│ ├── stl_numeric.h
│ ├── stl_pair.h
│ ├── stl_queue.h
│ ├── stl_range_errors.h
│ ├── stl_raw_storage_iter.h
│ ├── stl_relops.h
│ ├── stl_rope.h
│ ├── stl_set.h
│ ├── stl_slist.h
│ ├── stl_stack.h
│ ├── stl_string_fwd.h
│ ├── stl_tempbuf.h
│ ├── stl_threads.h
│ ├── stl_tree.h
│ ├── stl_uninitialized.h
│ ├── stl_vector.h
│ ├── string
│ ├── tempbuf.h
│ ├── tree.h
│ ├── type_traits.h
│ ├── utility
│ ├── valarray
│ ├── vector
│ └── vector.h
├── stl-gatieme/
│ ├── 1-stl_config/
│ │ ├── 1config-inclass-init.cpp
│ │ ├── 1config-inclass-init.o
│ │ ├── 1config-operator-overloading.cpp
│ │ ├── 1config-operator-overloading.o
│ │ ├── 1config-template-exp-special.cpp
│ │ ├── 1config-template-exp-special.o
│ │ ├── 1config-temporary-object.cpp
│ │ ├── 1config-temporary-object.o
│ │ ├── 1config.cpp
│ │ ├── 1config.o
│ │ ├── 1config10.cpp
│ │ ├── 1config10.o
│ │ ├── 1config11.cpp
│ │ ├── 1config11.o
│ │ ├── 1config2.cpp
│ │ ├── 1config2.o
│ │ ├── 1config3.cpp
│ │ ├── 1config5.cpp
│ │ ├── 1config5.o
│ │ ├── 1config8.cpp
│ │ ├── 1config8.o
│ │ ├── 1functor.cpp
│ │ ├── 1functor.o
│ │ ├── 1qsort.cpp
│ │ ├── 1qsort.o
│ │ ├── Makefile
│ │ └── stl_config.h
│ ├── 2-defalloc/
│ │ ├── 2jjalloc.h
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── defalloc.h
│ │ ├── simple_jjallocator.h
│ │ ├── stl_alloc.h
│ │ └── test.cpp
│ ├── 3-iterator/
│ │ ├── 3autoptr.cpp
│ │ ├── 3find.cpp
│ │ ├── 3function_template1.cpp
│ │ ├── 3function_template2.cpp
│ │ ├── 3function_template3.cpp
│ │ ├── 3mylist.h
│ │ ├── 3mylist_iter.h
│ │ ├── 3mylist_iter_stl.h
│ │ ├── 3mylist_iter_test.cpp
│ │ ├── 3tag_test.cpp
│ │ ├── 3templatespecial_class.cpp
│ │ ├── 3templatespecial_func.cpp
│ │ ├── 3test_typeid.cpp
│ │ ├── Makefile
│ │ ├── test_auto_ptr.cpp
│ │ ├── test_bad_typeid.cpp
│ │ └── typeinfo.h
│ ├── 4-sequence-containers/
│ │ ├── 4deque_test.cpp
│ │ ├── 4heap_test.cpp
│ │ ├── 4queue_test.cpp
│ │ ├── 4stack_test.cpp
│ │ ├── 4vector_reset.cpp
│ │ └── 4vector_test.cpp
│ ├── Make.defines.freebsd
│ ├── Make.defines.linux
│ ├── Make.defines.macos
│ ├── Make.defines.solaris
│ ├── Makefile
│ └── systype.sh
├── stl侯杰源码/
│ ├── Makefile
│ ├── Makefile.h
│ ├── README
│ ├── algo/
│ │ ├── Makefile
│ │ ├── accu1.cpp
│ │ ├── adjdiff1.cpp
│ │ ├── adjfind1.cpp
│ │ ├── algostuff.hpp
│ │ ├── bounds1.cpp
│ │ ├── bsearch1.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── copy3.cpp
│ │ ├── count1.cpp
│ │ ├── eqrange1.cpp
│ │ ├── equal1.cpp
│ │ ├── fill1.cpp
│ │ ├── find1.cpp
│ │ ├── find2.cpp
│ │ ├── findend1.cpp
│ │ ├── findof1.cpp
│ │ ├── foreach1.cpp
│ │ ├── foreach2.cpp
│ │ ├── foreach3.cpp
│ │ ├── generate.cpp
│ │ ├── heap1.cpp
│ │ ├── imerge1.cpp
│ │ ├── includes.cpp
│ │ ├── inner1.cpp
│ │ ├── lexico1.cpp
│ │ ├── merge1.cpp
│ │ ├── minmax1.cpp
│ │ ├── misma1.cpp
│ │ ├── nth1.cpp
│ │ ├── part1.cpp
│ │ ├── partsum1.cpp
│ │ ├── perm1.cpp
│ │ ├── psort1.cpp
│ │ ├── psort2.cpp
│ │ ├── random1.cpp
│ │ ├── relabs.cpp
│ │ ├── remove1.cpp
│ │ ├── remove2.cpp
│ │ ├── replace1.cpp
│ │ ├── replace2.cpp
│ │ ├── reverse1.cpp
│ │ ├── rotate1.cpp
│ │ ├── rotate2.cpp
│ │ ├── search1.cpp
│ │ ├── search2.cpp
│ │ ├── searchn1.cpp
│ │ ├── setalgos.cpp
│ │ ├── sort1.cpp
│ │ ├── sort2.cpp
│ │ ├── swap1.cpp
│ │ ├── transf1.cpp
│ │ ├── transf2.cpp
│ │ ├── unique1.cpp
│ │ ├── unique2.cpp
│ │ └── unique3.cpp
│ ├── cont/
│ │ ├── Makefile
│ │ ├── Queue.hpp
│ │ ├── Stack.hpp
│ │ ├── array1.cpp
│ │ ├── bitset1.cpp
│ │ ├── bitset2.cpp
│ │ ├── carray.hpp
│ │ ├── carray1.cpp
│ │ ├── countptr.hpp
│ │ ├── deque1.cpp
│ │ ├── list1.cpp
│ │ ├── map1.cpp
│ │ ├── mapcmp.cpp
│ │ ├── mapfind.cpp
│ │ ├── mmap1.cpp
│ │ ├── mset1.cpp
│ │ ├── newkey.hpp
│ │ ├── pqueue1.cpp
│ │ ├── print.hpp
│ │ ├── queue1.cpp
│ │ ├── queue2.cpp
│ │ ├── refsem1.cpp
│ │ ├── set1.cpp
│ │ ├── set2.cpp
│ │ ├── setcmp.cpp
│ │ ├── sortset.cpp
│ │ ├── sortvec.cpp
│ │ ├── stack1.cpp
│ │ ├── stack2.cpp
│ │ └── vector1.cpp
│ ├── fo/
│ │ ├── Makefile
│ │ ├── compose1.cpp
│ │ ├── compose10.hpp
│ │ ├── compose11.hpp
│ │ ├── compose12.hpp
│ │ ├── compose2.cpp
│ │ ├── compose21.hpp
│ │ ├── compose22.hpp
│ │ ├── compose3.cpp
│ │ ├── compose4.cpp
│ │ ├── fopow.hpp
│ │ ├── fopow1.cpp
│ │ ├── foreach3.cpp
│ │ ├── genera1.cpp
│ │ ├── genera2.cpp
│ │ ├── memfun1.cpp
│ │ ├── nullary.hpp
│ │ ├── print.hpp
│ │ ├── removeif.cpp
│ │ └── sort1.cpp
│ ├── i18n/
│ │ ├── Makefile
│ │ ├── loc1.cpp
│ │ ├── loc2.cpp
│ │ └── numget.cpp
│ ├── io/
│ │ ├── Makefile
│ │ ├── cat1.cpp
│ │ ├── cat2.cpp
│ │ ├── charcat1.cpp
│ │ ├── charcat2.cpp
│ │ ├── charset.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── countlines.cpp
│ │ ├── frac1in.hpp
│ │ ├── frac1out.hpp
│ │ ├── frac2in.hpp
│ │ ├── frac2out.hpp
│ │ ├── ignore.hpp
│ │ ├── ignore1.cpp
│ │ ├── ignoreparam.hpp
│ │ ├── ignoreparam1.cpp
│ │ ├── inbuf1.cpp
│ │ ├── inbuf1.hpp
│ │ ├── io1.cpp
│ │ ├── outbuf1.cpp
│ │ ├── outbuf1.hpp
│ │ ├── outbuf1x.cpp
│ │ ├── outbuf1x.hpp
│ │ ├── outbuf2.cpp
│ │ ├── outbuf2.hpp
│ │ ├── outbuf3.cpp
│ │ ├── outbuf3.hpp
│ │ ├── rdbuf1.cpp
│ │ ├── rdbuf2.cpp
│ │ ├── redirect.cpp
│ │ ├── rw1.cpp
│ │ ├── sstr1.cpp
│ │ ├── sum1.cpp
│ │ └── sum2.cpp
│ ├── iter/
│ │ ├── Makefile
│ │ ├── advance1.cpp
│ │ ├── advance2.cpp
│ │ ├── assoiter.cpp
│ │ ├── assoiter.hpp
│ │ ├── backins.cpp
│ │ ├── distance.cpp
│ │ ├── distance.hpp
│ │ ├── frontins.cpp
│ │ ├── inserter.cpp
│ │ ├── istriter.cpp
│ │ ├── itercat.cpp
│ │ ├── ostriter.cpp
│ │ ├── print.hpp
│ │ ├── reviter1.cpp
│ │ ├── reviter2.cpp
│ │ ├── reviter3.cpp
│ │ ├── reviter4.cpp
│ │ └── swap1.cpp
│ ├── memory/
│ │ ├── Makefile
│ │ ├── myalloc.hpp
│ │ └── myalloc1.cpp
│ ├── num/
│ │ ├── Makefile
│ │ ├── complex1.cpp
│ │ ├── complex2.cpp
│ │ ├── gslice1.cpp
│ │ ├── indi1.cpp
│ │ ├── masked1.cpp
│ │ ├── slice1.cpp
│ │ ├── val1.cpp
│ │ └── val2.cpp
│ ├── stl/
│ │ ├── Makefile
│ │ ├── add1.cpp
│ │ ├── algo1.cpp
│ │ ├── copy1.cpp
│ │ ├── copy2.cpp
│ │ ├── copy3.cpp
│ │ ├── deque1.cpp
│ │ ├── find1.cpp
│ │ ├── fo1.cpp
│ │ ├── foreach1.cpp
│ │ ├── foreach2.cpp
│ │ ├── ioiter1.cpp
│ │ ├── iterbug1.cpp
│ │ ├── list1.cpp
│ │ ├── list2.cpp
│ │ ├── map1.cpp
│ │ ├── mmap1.cpp
│ │ ├── prime1.cpp
│ │ ├── print.hpp
│ │ ├── remove1.cpp
│ │ ├── remove2.cpp
│ │ ├── remove3.cpp
│ │ ├── remove4.cpp
│ │ ├── riter1.cpp
│ │ ├── set1.cpp
│ │ ├── sort1.cpp
│ │ ├── transform1.cpp
│ │ └── vector1.cpp
│ ├── string/
│ │ ├── Makefile
│ │ ├── icstring.hpp
│ │ ├── icstring1.cpp
│ │ ├── iter1.cpp
│ │ ├── iter2.cpp
│ │ ├── iter3.cpp
│ │ ├── string1.cpp
│ │ ├── string2.cpp
│ │ └── unique.cpp
│ └── util/
│ ├── Makefile
│ ├── autoptr.hpp
│ ├── autoptr1.cpp
│ ├── autoptr2.cpp
│ ├── defalloc.hpp
│ ├── limits1.cpp
│ └── minmax1.cpp
└── tass-sgi-stl-2.91.57-source/
├── JJHOU.TXT
├── PlotFile.h
├── SFile.h
├── algo.h
├── algobase.h
├── algorithm
├── alloc.h
├── builtinbuf.h
├── bvector.h
├── cassert
├── cctype
├── cerrno
├── cfloat
├── ciso646
├── climits
├── clocale
├── cmath
├── complex
├── complex.h
├── csetjmp
├── csignal
├── cstdarg
├── cstddef
├── cstdio
├── cstdlib
├── cstring
├── ctime
├── cwchar
├── cwctype
├── defalloc.h
├── deque
├── deque.h
├── editbuf.h
├── floatio.h
├── fstream
├── fstream.h
├── function.h
├── functional
├── hash_map
├── hash_map.h
├── hash_set
├── hash_set.h
├── hashtable.h
├── heap.h
├── indstream.h
├── iolibio.h
├── iomanip
├── iomanip.h
├── iosfwd
├── iostdio.h
├── iostream
├── iostream.h
├── iostreamP.h
├── istream.h
├── iterator
├── iterator.h
├── libio.h
├── libioP.h
├── list
├── list.h
├── map
├── map.h
├── memory
├── multimap.h
├── multiset.h
├── numeric
├── ostream.h
├── pair.h
├── parsestream.h
├── pfstream.h
├── procbuf.h
├── pthread_alloc
├── pthread_alloc.h
├── queue
├── rope
├── rope.h
├── ropeimpl.h
├── set
├── set.h
├── sgi-stl-2.91.57-source.IAB
├── sgi-stl-2.91.57-source.IAD
├── sgi-stl-2.91.57-source.IMB
├── sgi-stl-2.91.57-source.IMD
├── sgi-stl-2.91.57-source.PFI
├── sgi-stl-2.91.57-source.PO
├── sgi-stl-2.91.57-source.PR
├── sgi-stl-2.91.57-source.PS
├── sgi-stl-2.91.57-source.WK3
├── slist
├── slist.h
├── stack
├── stack.h
├── std/
│ ├── bastring.cc
│ ├── bastring.h
│ ├── complext.cc
│ ├── complext.h
│ ├── dcomplex.h
│ ├── fcomplex.h
│ ├── ldcomplex.h
│ └── straits.h
├── stdexcept
├── stdiostream.h
├── stl.h
├── stl_algo.h
├── stl_algobase.h
├── stl_alloc.h
├── stl_bvector.h
├── stl_config.h
├── stl_construct.h
├── stl_deque.h
├── stl_function.h
├── stl_hash_fun.h
├── stl_hash_map.h
├── stl_hash_set.h
├── stl_hashtable.h
├── stl_heap.h
├── stl_iterator.h
├── stl_list.h
├── stl_map.h
├── stl_multimap.h
├── stl_multiset.h
├── stl_numeric.h
├── stl_pair.h
├── stl_queue.h
├── stl_raw_storage_iter.h
├── stl_relops.h
├── stl_rope.h
├── stl_set.h
├── stl_slist.h
├── stl_stack.h
├── stl_tempbuf.h
├── stl_tree.h
├── stl_uninitialized.h
├── stl_vector.h
├── stream.h
├── streambuf.h
├── strfile.h
├── string
├── strstream
├── strstream.h
├── tempbuf.h
├── tree.h
├── type_traits.h
├── utility
├── vector
└── vector.h
Showing preview only (282K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3561 symbols across 343 files)
FILE: stl-3.3-source/char_traits.h
type _IntT (line 31) | typedef _IntT int_type;
type streamoff (line 33) | typedef streamoff off_type;
type streampos (line 34) | typedef streampos pos_type;
type mbstate_t (line 35) | typedef mbstate_t state_type;
function assign (line 38) | static void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; }
function eq (line 39) | static bool eq(const _CharT& __c1, const _CharT& __c2)
function lt (line 41) | static bool lt(const _CharT& __c1, const _CharT& __c2)
function compare (line 44) | static int compare(const _CharT* __s1, const _CharT* __s2, size_t __n) {
function length (line 51) | static size_t length(const _CharT* __s) {
function _CharT (line 59) | static const _CharT* find(const _CharT* __s, size_t __n, const _CharT& __c)
function _CharT (line 67) | static _CharT* move(_CharT* __s1, const _CharT* __s2, size_t __n) {
function _CharT (line 72) | static _CharT* copy(_CharT* __s1, const _CharT* __s2, size_t __n) {
function _CharT (line 77) | static _CharT* assign(_CharT* __s, size_t __n, _CharT __c) {
function int_type (line 83) | static int_type not_eof(const int_type& __c) {
function char_type (line 87) | static char_type to_char_type(const int_type& __c) {
function int_type (line 91) | static int_type to_int_type(const char_type& __c) {
function eq_int_type (line 95) | static bool eq_int_type(const int_type& __c1, const int_type& __c2) {
function int_type (line 99) | static int_type eof() {
function int_type (line 123) | static int_type to_int_type(const char_type& __c) {
function compare (line 127) | static int compare(const char* __s1, const char* __s2, size_t __n)
function length (line 130) | static size_t length(const char* __s) { return strlen(__s); }
function assign (line 132) | static void assign(char& __c1, const char& __c2) { __c1 = __c2; }
FILE: stl-3.3-source/concept_checks.h
type _Tp (line 234) | typedef _Tp _Type;
type _Tp (line 238) | typedef _Tp _Type;
function __sink_unused_warning (line 244) | __sink_unused_warning(_Type) { }
function __type_X_is_not_convertible_to_type_Y (line 248) | static void
function __type_X_not_same_as_type_Y (line 260) | static void
function _Ret (line 271) | static _Ret __generator_requirement_violation(_Func& __f) {
function _Ret (line 286) | static _Ret
function _Ret (line 304) | static _Ret
function __assignment_operator_requirement_violation (line 360) | struct _STL_ERROR {
function _Type (line 374) | _Type
function _Type (line 380) | _Type
function _Type (line 387) | _Type
function _Type (line 394) | _Type
function _Type (line 400) | _Type
function __dereference_operator_requirement_violation (line 406) | void
function __dereference_operator_and_assignment_requirement_violation (line 411) | void
function __preincrement_operator_requirement_violation (line 416) | void
function __postincrement_operator_requirement_violation (line 421) | void
function __predecrement_operator_requirement_violation (line 426) | void
function __postdecrement_operator_requirement_violation (line 431) | void
function __postincrement_operator_and_assignment_requirement_violation (line 436) | void
function _Iterator (line 442) | _Iterator
function _Iterator (line 449) | _Iterator
function _Iterator (line 456) | _Iterator
function _Iterator (line 463) | _Iterator
function _Distance (line 469) | _Distance
function _Type (line 476) | _Type
function __element_assignment_operator_requirement_violation (line 482) | void
function __STL_END_NAMESPACE (line 495) | __STL_END_NAMESPACE
type typename (line 504) | typedef typename __STD::iterator_traits<_Iter>::difference_type
type typename (line 510) | typedef typename __STD::iterator_traits<_Iter>::reference reference;
type typename (line 515) | typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
type typename (line 520) | typedef typename __STD::iterator_traits<_Iter>::iterator_category
function _Assignable_requirement_violation (line 529) | static void _Assignable_requirement_violation(_Type __a) {
function _DefaultConstructible_requirement_violation (line 542) | static void _DefaultConstructible_requirement_violation(_Type __a) {
function _EqualityComparable_requirement_violation (line 551) | static void _EqualityComparable_requirement_violation(_Type __a) {
function _LessThanComparable_requirement_violation (line 559) | static void _LessThanComparable_requirement_violation(_Type __a) {
function _TrivialIterator_requirement_violation (line 568) | static void
function _Mutable_TrivialIterator_requirement_violation (line 589) | static void
function _InputIterator_requirement_violation (line 602) | static void
function _OutputIterator_requirement_violation (line 622) | static void
function _ForwardIterator_requirement_violation (line 642) | static void
function _Mutable_ForwardIterator_requirement_violation (line 652) | static void
function _BidirectionalIterator_requirement_violation (line 666) | static void
function _Mutable_BidirectionalIterator_requirement_violation (line 679) | static void
function _RandomAccessIterator_requirement_violation (line 703) | static void
function _Mutable_RandomAccessIterator_requirement_violation (line 742) | static void
function _Allocator_requirement_violation (line 783) | static void
FILE: stl-3.3-source/container_concepts.h
function __const_begin_iterator_accessor_requirement_violation (line 31) | struct _ERROR_IN_STL_CONTAINER {
function __end_iterator_accessor_requirement_violation (line 46) | void
function __const_end_iterator_accessor_requirement_violation (line 51) | void
function __rbegin_iterator_accessor_requirement_violation (line 57) | void
function __const_rbegin_iterator_accessor_requirement_violation (line 62) | void
function __rend_iterator_accessor_requirement_violation (line 67) | void
function __const_rend_iterator_accessor_requirement_violation (line 72) | void
function __size_function_must_be_const (line 77) | void
function __max_size_function_must_be_const (line 88) | void
function __empty_function_must_be_const (line 99) | void
function _Container_requirement_violation (line 125) | static void
function _ForwardContainer_requirement_violation (line 158) | static void
function _ReversibleContainer_requirement_violation (line 176) | static void
function _const_ReversibleContainer_requirement_violation (line 198) | static void
function _RandomAccessContainer_requirement_violation (line 224) | static void
FILE: stl-3.3-source/defalloc.h
function T (line 38) | T* allocate(ptrdiff_t size, T*) {
function deallocate (line 50) | void deallocate(T* buffer) {
type T (line 58) | typedef T* pointer;
type T (line 59) | typedef const T* const_pointer;
type T (line 60) | typedef T& reference;
type T (line 61) | typedef const T& const_reference;
type size_type (line 62) | typedef size_t size_type;
type difference_type (line 63) | typedef ptrdiff_t difference_type;
function pointer (line 64) | pointer allocate(size_type n) {
function deallocate (line 67) | void deallocate(pointer p) { ::deallocate(p); }
function pointer (line 68) | pointer address(reference x) { return (pointer)&x; }
function const_pointer (line 69) | const_pointer const_address(const_reference x) {
function size_type (line 72) | size_type init_page_size() {
function class (line 80) | class allocator<void> {
FILE: stl-3.3-source/ropeimpl.h
type basic_ostream (line 806) | typedef basic_ostream<_CharT,_Traits> _Insert_ostream;
type ostream (line 808) | typedef ostream _Insert_ostream;
function _Rope_fill (line 915) | inline void _Rope_fill(ostream& __o, size_t __n)
function _Rope_is_simple (line 925) | bool _Rope_is_simple(_CharT*) { return false; }
function _Rope_is_simple (line 926) | inline bool _Rope_is_simple(char*) { return true; }
function _Rope_is_simple (line 927) | inline bool _Rope_is_simple(wchar_t*) { return true; }
type typename (line 1534) | typedef typename _Rope_iterator::value_type _CharT;
type typename (line 1535) | typedef typename _Rope_iterator::_allocator_type _Alloc;
function rotate (line 1555) | inline void rotate(_Rope_iterator<char,__STL_DEFAULT_ALLOCATOR(char)> __...
function rotate (line 1570) | inline void rotate(
FILE: stl-3.3-source/sequence_concepts.h
function __fill_default_constructor_requirement_violation (line 26) | struct _ERROR_IN_STL_SEQ {
function __const_front_function_requirement_violation (line 103) | void
function __const_back_function_requirement_violation (line 116) | void
function _Sequence_requirement_violation (line 157) | static void
function _FrontInsertionSequence_requirement_violation (line 178) | static void
function _BackInsertionSequence_requirement_violation (line 190) | static void
FILE: stl-3.3-source/stl_algo.h
function _InputIter (line 97) | _InputIter find(_InputIter __first, _InputIter __last,
function _InputIter (line 107) | _InputIter find_if(_InputIter __first, _InputIter __last,
function _InputIter (line 197) | _InputIter find(_InputIter __first, _InputIter __last,
function _InputIter (line 207) | _InputIter find_if(_InputIter __first, _InputIter __last,
function _OutputIter (line 678) | _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 695) | _OutputIter unique_copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 723) | _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 746) | _OutputIter unique_copy(_InputIter __first, _InputIter __last,
function reverse (line 796) | void reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
function _ForwardIter (line 948) | _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle,
function _Distance (line 969) | _Distance __random_number(_Distance __n) {
function random_shuffle (line 980) | void random_shuffle(_RandomAccessIter __first,
function _RandomAccessIter (line 1094) | _RandomAccessIter
function _RandomAccessIter (line 1107) | _RandomAccessIter
function _ForwardIter (line 1169) | _ForwardIter partition(_ForwardIter __first,
function _ForwardIter (line 1231) | _ForwardIter
function _ForwardIter (line 1246) | _ForwardIter stable_partition(_ForwardIter __first,
function __linear_insert (line 1326) | void __linear_insert(_RandomAccessIter __first,
function __linear_insert (line 1338) | void __linear_insert(_RandomAccessIter __first,
function __unguarded_insertion_sort (line 1386) | void __unguarded_insertion_sort(_RandomAccessIter __first,
function _Size (line 1416) | _Size __lg(_Size __n) {
function sort (line 1466) | void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
function sort (line 1479) | void sort(_RandomAccessIter __first, _RandomAccessIter __last,
function stable_sort (line 1709) | void stable_sort(_RandomAccessIter __first,
function partial_sort (line 1756) | void partial_sort(_RandomAccessIter __first,
function _RandomAccessIter (line 1793) | _RandomAccessIter
function _RandomAccessIter (line 1838) | _RandomAccessIter
function nth_element (line 1903) | void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
function _ForwardIter (line 1940) | _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
function _ForwardIter (line 1975) | _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
function _ForwardIter (line 2010) | _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
function _ForwardIter (line 2045) | _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
function inplace_merge (line 2512) | void inplace_merge(_BidirectionalIter __first,
type reverse_iterator (line 3111) | typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
type reverse_iterator (line 3112) | typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
type reverse_iterator (line 3138) | typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
type reverse_iterator (line 3139) | typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
function _ForwardIter1 (line 3160) | _ForwardIter1
function _ForwardIter1 (line 3176) | _ForwardIter1
function is_heap (line 3225) | bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
function is_heap (line 3235) | bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
FILE: stl-3.3-source/stl_algobase.h
function iter_swap (line 79) | void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b) {
function _OutputIter (line 139) | _OutputIter __copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 149) | _OutputIter
function _Tp (line 162) | _Tp*
function _OutputIter (line 171) | _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
function _OutputIter (line 179) | _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
function _Tp (line 189) | _Tp* __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result,
function _Tp (line 197) | _Tp* __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result,
function _OutputIter (line 204) | _OutputIter __copy_aux(_InputIter __first, _InputIter __last,
function _OutputIter (line 212) | _OutputIter copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 225) | static _OutputIter copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 250) | _OutputIter copy(_InputIter __first, _InputIter __last,
function _OutputIter (line 267) | _OutputIter copy(_InputIter __first, _InputIter __last,
function _BidirectionalIter (line 321) | _BidirectionalIter __copy_backward(_RandomAccessIter __first,
type typename (line 343) | typedef typename iterator_traits<_BidirectionalIter1>::iterator_category
type typename (line 345) | typedef typename iterator_traits<_BidirectionalIter1>::difference_type
function _BidirectionalIter2 (line 348) | static _BidirectionalIter2 copy(_BidirectionalIter1 __first,
function _BI2 (line 375) | _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
function _BI2 (line 390) | _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
function fill (line 458) | inline void fill(unsigned char* __first, unsigned char* __last,
function fill (line 464) | inline void fill(signed char* __first, signed char* __last,
function fill (line 470) | inline void fill(char* __first, char* __last, const char& __c) {
function equal (line 534) | bool equal(_InputIter1 __first1, _InputIter1 __last1,
function equal (line 549) | bool equal(_InputIter1 __first1, _InputIter1 __last1,
function lexicographical_compare (line 598) | inline bool
function lexicographical_compare (line 610) | inline bool lexicographical_compare(const char* __first1, const char* __...
function __lexicographical_compare_3way (line 646) | inline int
function __lexicographical_compare_3way (line 659) | inline int
FILE: stl-3.3-source/stl_alloc.h
function deallocate (line 129) | static void deallocate(void* __p, size_t /* __n */)
type __malloc_alloc_template (line 188) | typedef __malloc_alloc_template<0> malloc_alloc;
function _Tp (line 196) | static _Tp* allocate(void)
function deallocate (line 198) | static void deallocate(_Tp* __p, size_t __n)
function deallocate (line 200) | static void deallocate(_Tp* __p)
function deallocate (line 227) | static void deallocate(void* __p, size_t __n)
type malloc_alloc (line 250) | typedef malloc_alloc alloc;
type malloc_alloc (line 251) | typedef malloc_alloc single_client_alloc;
function _S_round_up (line 299) | static size_t
function _S_freelist_index (line 315) | static size_t _S_freelist_index(size_t __bytes) {
function class (line 339) | class _Lock {
function deallocate (line 378) | static void deallocate(void* __p, size_t __n)
type __default_alloc_template (line 402) | typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
type alloc (line 590) | typedef alloc _Alloc;
type difference_type (line 593) | typedef ptrdiff_t difference_type;
type _Tp (line 594) | typedef _Tp* pointer;
type _Tp (line 595) | typedef const _Tp* const_pointer;
type _Tp (line 596) | typedef _Tp& reference;
type _Tp (line 597) | typedef const _Tp& const_reference;
type _Tp (line 598) | typedef _Tp value_type;
type allocator (line 601) | typedef allocator<_Tp1> other;
function __STL_NOTHROW (line 605) | allocator(const allocator&) __STL_NOTHROW {}
type difference_type (line 634) | typedef ptrdiff_t difference_type;
type value_type (line 637) | typedef void value_type;
type allocator (line 640) | typedef allocator<_Tp1> other;
type size_type (line 668) | typedef size_t size_type;
type difference_type (line 669) | typedef ptrdiff_t difference_type;
type _Tp (line 670) | typedef _Tp* pointer;
type _Tp (line 671) | typedef const _Tp* const_pointer;
type _Tp (line 672) | typedef _Tp& reference;
type _Tp (line 673) | typedef const _Tp& const_reference;
type _Tp (line 674) | typedef _Tp value_type;
type __allocator (line 677) | typedef __allocator<_Tp1, _Alloc> other;
function __underlying_alloc (line 681) | __allocator(const __allocator& __a) __STL_NOTHROW
function pointer (line 688) | pointer address(reference __x) const { return &__x; }
function const_pointer (line 689) | const_pointer address(const_reference __x) const { return &__x; }
function deallocate (line 699) | void deallocate(pointer __p, size_type __n)
function construct (line 705) | void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
function destroy (line 706) | void destroy(pointer __p) { __p->~_Tp(); }
type difference_type (line 712) | typedef ptrdiff_t difference_type;
type value_type (line 715) | typedef void value_type;
type __allocator (line 718) | typedef __allocator<_Tp1, _Alloc> other;
type typename (line 805) | typedef typename _Allocator::__STL_TEMPLATE
type simple_alloc (line 818) | typedef simple_alloc<_Tp, alloc> _Alloc_type;
type allocator (line 819) | typedef allocator<_Tp> allocator_type;
type simple_alloc (line 828) | typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
type __allocator (line 829) | typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
type simple_alloc (line 836) | typedef simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
type __allocator (line 838) | typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
type simple_alloc (line 846) | typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
type __allocator (line 847) | typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
type simple_alloc (line 858) | typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
type __allocator (line 859) | typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
type simple_alloc (line 868) | typedef simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
type __allocator (line 870) | typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
type simple_alloc (line 878) | typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
type __allocator (line 879) | typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
FILE: stl-3.3-source/stl_bvector.h
type _Bit_reference (line 43) | struct _Bit_reference {
function flip (line 65) | void flip() { *_M_p ^= _M_mask; }
function swap (line 68) | inline void swap(_Bit_reference __x, _Bit_reference __y)
type _Bit_iterator_base (line 75) | struct _Bit_iterator_base
function _M_bump_down (line 89) | void _M_bump_down() {
function _M_incr (line 96) | void _M_incr(ptrdiff_t __i) {
function _Bit_iterator_base (line 133) | struct _Bit_iterator : public _Bit_iterator_base
function reference (line 179) | reference operator[](difference_type __i) { return *(*this + __i); }
function _Bit_iterator_base (line 186) | struct _Bit_const_iterator : public _Bit_iterator_base
function const_reference (line 236) | const_reference operator[](difference_type __i) {
function _M_deallocate (line 294) | void _M_deallocate() {
function _Base (line 316) | _Bvector_base(const allocator_type& __a) : _Base(__a) {}
function _M_deallocate (line 338) | void _M_deallocate() {
type size_type (line 379) | typedef size_t size_type;
type difference_type (line 380) | typedef ptrdiff_t difference_type;
type _Bit_reference (line 381) | typedef _Bit_reference reference;
type const_reference (line 382) | typedef bool const_reference;
type _Bit_reference (line 383) | typedef _Bit_reference* pointer;
type _Bit_iterator (line 386) | typedef _Bit_iterator iterator;
type _Bit_const_iterator (line 387) | typedef _Bit_const_iterator const_iterator;
type reverse_iterator (line 390) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 391) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 393) | typedef reverse_iterator<const_iterator, value_type, const_reference,
type reverse_iterator (line 395) | typedef reverse_iterator<iterator, value_type, reference, difference_type>
type typename (line 399) | typedef typename __BVECTOR_BASE::allocator_type allocator_type;
function _M_insert_aux (line 420) | void _M_insert_aux(iterator __position, bool __x) {
function iterator (line 498) | iterator end() { return _M_finish; }
function reverse_iterator (line 501) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 505) | reverse_iterator rend() { return reverse_iterator(begin()); }
function reference (line 517) | reference operator[](size_type __n)
function const_reference (line 519) | const_reference operator[](size_type __n) const
function _M_range_check (line 523) | void _M_range_check(size_type __n) const {
function reference (line 528) | reference at(size_type __n)
function const_reference (line 530) | const_reference at(size_type __n) const
function __BVECTOR_BASE (line 535) | __BVECTOR_BASE(__a) {}
function explicit (line 545) | explicit __VECTOR(size_type __n)
function __BVECTOR_BASE (line 552) | __VECTOR(const __VECTOR& __x) : __BVECTOR_BASE(__x.get_allocator()) {
function __BVECTOR_BASE (line 576) | __BVECTOR_BASE(__a)
function _M_fill_assign (line 623) | void _M_fill_assign(size_t __n, bool __x) {
function assign (line 634) | void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
type typename (line 640) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function reserve (line 681) | void reserve(size_type __n) {
function reference (line 691) | reference front() { return *begin(); }
function reference (line 693) | reference back() { return *(end() - 1); }
function push_back (line 695) | void push_back(bool __x) {
function swap (line 701) | void swap(__BVECTOR& __x) {
function iterator (line 706) | iterator insert(iterator __position, bool __x = bool()) {
type typename (line 734) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function insert (line 739) | void insert(iterator __position,
function insert (line 761) | void insert(iterator __position, const bool* __first, const bool* __last) {
function _M_fill_insert (line 783) | void _M_fill_insert(iterator __position, size_type __n, bool __x) {
function insert (line 802) | void insert(iterator __position, size_type __n, bool __x) {
function pop_back (line 806) | void pop_back() { --_M_finish; }
function iterator (line 807) | iterator erase(iterator __position) {
function iterator (line 813) | iterator erase(iterator __first, iterator __last) {
function resize (line 817) | void resize(size_type __new_size, bool __x = bool()) {
function flip (line 823) | void flip() {
function clear (line 828) | void clear() { erase(begin(), end()); }
type vector (line 834) | typedef vector<bool, alloc> bit_vector;
function swap (line 838) | inline void swap(bit_vector& __x, bit_vector& __y) {
FILE: stl-3.3-source/stl_construct.h
function __destroy_aux (line 70) | void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}
function __destroy (line 73) | void
function _Destroy (line 82) | void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
function _Destroy (line 86) | inline void _Destroy(char*, char*) {}
function _Destroy (line 87) | inline void _Destroy(int*, int*) {}
function _Destroy (line 88) | inline void _Destroy(long*, long*) {}
function _Destroy (line 89) | inline void _Destroy(float*, float*) {}
function _Destroy (line 90) | inline void _Destroy(double*, double*) {}
function _Destroy (line 92) | inline void _Destroy(wchar_t*, wchar_t*) {}
function construct (line 99) | void construct(_T1* __p, const _T2& __value) {
function construct (line 104) | void construct(_T1* __p) {
function destroy (line 109) | void destroy(_Tp* __pointer) {
function destroy (line 114) | void destroy(_ForwardIterator __first, _ForwardIterator __last) {
FILE: stl-3.3-source/stl_ctraits_fns.h
function const (line 32) | bool operator()(const typename _Traits::char_type& __x,
FILE: stl-3.3-source/stl_deque.h
function __deque_buf_size (line 79) | inline size_t __deque_buf_size(size_t __size) {
type _Deque_iterator (line 85) | typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
type _Deque_iterator (line 86) | typedef _Deque_iterator<_Tp, const
function _S_buffer_size (line 87) | static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
type random_access_iterator_tag (line 89) | typedef random_access_iterator_tag iterator_category;
type _Tp (line 90) | typedef _Tp value_type;
type _Ptr (line 91) | typedef _Ptr pointer;
type _Ref (line 92) | typedef _Ref reference;
type size_type (line 93) | typedef size_t size_type;
type difference_type (line 94) | typedef ptrdiff_t difference_type;
type _Tp (line 95) | typedef _Tp** _Map_pointer;
type _Deque_iterator (line 97) | typedef _Deque_iterator _Self;
function pointer (line 114) | pointer operator->() const { return _M_cur; }
function reference (line 179) | reference operator[](difference_type __n) const { return *(*this + __n); }
function operator (line 181) | bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; }
function operator (line 182) | bool operator!=(const _Self& __x) const { return !(*this == __x); }
function operator (line 183) | bool operator<(const _Self& __x) const {
function operator (line 187) | bool operator>(const _Self& __x) const { return __x < *this; }
function operator (line 188) | bool operator<=(const _Self& __x) const { return !(__x < *this); }
function operator (line 189) | bool operator>=(const _Self& __x) const { return !(*this < __x); }
function _M_set_node (line 191) | void _M_set_node(_Map_pointer __new_node) {
function random_access_iterator_tag (line 208) | random_access_iterator_tag
function _Tp (line 215) | _Tp* value_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) { return 0; }
function _Tp (line 251) | _Tp* _M_allocate_node() {
function _M_deallocate_node (line 254) | void _M_deallocate_node(_Tp* __p) {
function _Tp (line 257) | _Tp** _M_allocate_map(size_t __n)
function _M_deallocate_map (line 259) | void _M_deallocate_map(_Tp** __p, size_t __n)
type typename (line 271) | typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
type typename (line 278) | typedef typename _Alloc_traits<_Tp*, _Alloc>::_Alloc_type _Map_alloc_type;
function _Tp (line 280) | _Tp* _M_allocate_node() {
function _M_deallocate_node (line 283) | void _M_deallocate_node(_Tp* __p) {
function _Tp (line 286) | _Tp** _M_allocate_map(size_t __n)
function _M_deallocate_map (line 288) | void _M_deallocate_map(_Tp** __p, size_t __n)
type typename (line 304) | typedef typename _Base::allocator_type allocator_type;
type _Deque_iterator (line 305) | typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator;
type _Deque_iterator (line 306) | typedef _Deque_iterator<_Tp,const
type _Deque_iterator (line 332) | typedef _Deque_iterator<_Tp,const
type _Alloc (line 334) | typedef _Alloc allocator_type;
type simple_alloc (line 357) | typedef simple_alloc<_Tp, _Alloc> _Node_alloc_type;
type simple_alloc (line 358) | typedef simple_alloc<_Tp*, _Alloc> _Map_alloc_type;
function _Tp (line 360) | _Tp* _M_allocate_node()
function _M_deallocate_node (line 362) | void _M_deallocate_node(_Tp* __p)
function _Tp (line 364) | _Tp** _M_allocate_map(size_t __n)
function _M_deallocate_map (line 366) | void _M_deallocate_map(_Tp** __p, size_t __n)
type _Deque_base (line 433) | typedef _Deque_base<_Tp, _Alloc> _Base;
type value_type (line 436) | typedef value_type* pointer;
type value_type (line 437) | typedef const value_type* const_pointer;
type value_type (line 438) | typedef value_type& reference;
type value_type (line 439) | typedef const value_type& const_reference;
type size_type (line 440) | typedef size_t size_type;
type difference_type (line 441) | typedef ptrdiff_t difference_type;
type typename (line 443) | typedef typename _Base::allocator_type allocator_type;
type typename (line 447) | typedef typename _Base::iterator iterator;
type typename (line 448) | typedef typename _Base::const_iterator const_iterator;
type reverse_iterator (line 451) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 452) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 454) | typedef reverse_iterator<const_iterator, value_type, const_reference,
type reverse_iterator (line 457) | typedef reverse_iterator<iterator, value_type, reference, difference_type>
function _S_buffer_size (line 463) | static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
function iterator (line 483) | iterator end() { return _M_finish; }
function reverse_iterator (line 487) | reverse_iterator rbegin() { return reverse_iterator(_M_finish); }
function reverse_iterator (line 488) | reverse_iterator rend() { return reverse_iterator(_M_start); }
function reference (line 494) | reference operator[](size_type __n)
function const_reference (line 496) | const_reference operator[](size_type __n) const
function _M_range_check (line 500) | void _M_range_check(size_type __n) const {
function reference (line 505) | reference at(size_type __n)
function const_reference (line 507) | const_reference at(size_type __n) const
function reference (line 511) | reference front() { return *_M_start; }
function reference (line 512) | reference back() {
function _Base (line 531) | deque(const deque& __x) : _Base(__x.get_allocator(), __x.size())
function explicit (line 536) | explicit deque(size_type __n) : _Base(allocator_type(), __n)
function _Base (line 544) | _Base(__a) {
function swap (line 590) | void swap(deque& __x) {
function assign (line 614) | void assign(size_type __n, const _Tp& __val) {
type typename (line 622) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function push_back (line 670) | void push_back() {
function push_front (line 679) | void push_front(const value_type& __t) {
function push_front (line 688) | void push_front() {
function pop_back (line 698) | void pop_back() {
function pop_front (line 707) | void pop_front() {
function iterator (line 734) | iterator insert(iterator __position)
function insert (line 737) | void insert(iterator __pos, size_type __n, const value_type& __x)
type typename (line 747) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function resize (line 773) | void resize(size_type __new_size, const value_type& __x) {
function resize (line 781) | void resize(size_type new_size) { resize(new_size, value_type()); }
function iterator (line 865) | iterator _M_reserve_elements_at_front(size_type __n) {
function iterator (line 872) | iterator _M_reserve_elements_at_back(size_type __n) {
function else (line 933) | else if (__pos._M_cur == _M_finish._M_cur) {
function else (line 961) | else if (__pos._M_cur == _M_finish._M_cur) {
function else (line 987) | else if (__pos._M_cur == _M_finish._M_cur) {
function else (line 1212) | else if (__pos._M_cur == _M_finish._M_cur) {
FILE: stl-3.3-source/stl_exception.h
function __STL_BEGIN_NAMESPACE (line 39) | __STL_BEGIN_NAMESPACE
FILE: stl-3.3-source/stl_function.h
type unary_function (line 37) | struct unary_function {
type _Arg1 (line 44) | typedef _Arg1 first_argument_type;
type _Arg2 (line 45) | typedef _Arg2 second_argument_type;
type _Result (line 46) | typedef _Result result_type;
function _Tp (line 81) | _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
function _Tp (line 87) | _Tp operator()(const _Tp& __x) const { return -__x; }
function const (line 93) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __...
function const (line 99) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __...
function const (line 105) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
function const (line 111) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
function const (line 117) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __...
function const (line 123) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __...
function const (line 129) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __...
function const (line 135) | bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __...
function const (line 141) | bool operator()(const _Tp& __x) const { return !__x; }
function const (line 151) | bool operator()(const typename _Predicate::argument_type& __x) const {
function const (line 172) | bool operator()(const typename _Predicate::first_argument_type& __x,
function typename (line 197) | typename _Operation::result_type
type typename (line 207) | typedef typename _Operation::first_argument_type _Arg1_type;
function typename (line 222) | typename _Operation::result_type
type typename (line 232) | typedef typename _Operation::second_argument_type _Arg2_type;
function typename (line 249) | typename _Operation1::result_type
function typename (line 274) | typename _Operation1::result_type
function explicit (line 295) | explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
function _Result (line 296) | _Result operator()(_Arg __x) const { return _M_ptr(__x); }
function explicit (line 312) | explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
function _Result (line 314) | _Result operator()(_Arg1 __x, _Arg2 __y) const {
function _Arg2 (line 360) | _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
type _Result (line 375) | typedef _Result result_type;
function _M_val (line 378) | _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
type _Argument (line 384) | typedef _Argument argument_type;
type _Result (line 385) | typedef _Result result_type;
function _M_val (line 388) | _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
function result_type (line 389) | const result_type& operator()(const _Argument&) const { return _M_val; }
type _Arg1 (line 394) | typedef _Arg1 first_argument_type;
type _Arg2 (line 395) | typedef _Arg2 second_argument_type;
type _Result (line 396) | typedef _Result result_type;
function _M_val (line 399) | _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
function result_type (line 400) | const result_type& operator()(const _Arg1&, const _Arg2&) const {
function _M_initialize (line 464) | void _M_initialize(unsigned int __seed)
function _Ret (line 515) | _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
function _Ret (line 524) | _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
function _Ret (line 534) | _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
function explicit (line 570) | explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
function _Ret (line 571) | _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
function _Ret (line 580) | _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x...
function explicit (line 590) | explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
function const (line 591) | void operator()(_Tp* __p) const { (__p->*_M_f)(); }
function explicit (line 599) | explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
function const (line 600) | void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
function explicit (line 608) | explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
function const (line 609) | void operator()(_Tp& __r) const { (__r.*_M_f)(); }
function explicit (line 617) | explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
function const (line 618) | void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
function explicit (line 626) | explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
function const (line 627) | void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
function explicit (line 636) | explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
function const (line 637) | void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
function explicit (line 646) | explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
function const (line 647) | void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
function explicit (line 656) | explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf...
function const (line 657) | void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
FILE: stl-3.3-source/stl_hash_fun.h
function __STL_BEGIN_NAMESPACE (line 36) | __STL_BEGIN_NAMESPACE
function __stl_hash_string (line 40) | inline size_t __stl_hash_string(const char* __s)
function const (line 51) | size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
function const (line 56) | size_t operator()(const char* __s) const { return __stl_hash_string(__s); }
function const (line 60) | size_t operator()(char __x) const { return __x; }
function const (line 63) | size_t operator()(unsigned char __x) const { return __x; }
function const (line 66) | size_t operator()(unsigned char __x) const { return __x; }
function const (line 69) | size_t operator()(short __x) const { return __x; }
function const (line 72) | size_t operator()(unsigned short __x) const { return __x; }
function const (line 75) | size_t operator()(int __x) const { return __x; }
function const (line 78) | size_t operator()(unsigned int __x) const { return __x; }
function const (line 81) | size_t operator()(long __x) const { return __x; }
function const (line 84) | size_t operator()(unsigned long __x) const { return __x; }
FILE: stl-3.3-source/stl_hash_map.h
type _Tp (line 73) | typedef _Tp data_type;
type _Tp (line 74) | typedef _Tp mapped_type;
type typename (line 75) | typedef typename _Ht::value_type value_type;
type typename (line 76) | typedef typename _Ht::hasher hasher;
type typename (line 77) | typedef typename _Ht::key_equal key_equal;
type typename (line 79) | typedef typename _Ht::size_type size_type;
type typename (line 80) | typedef typename _Ht::difference_type difference_type;
type typename (line 81) | typedef typename _Ht::pointer pointer;
type typename (line 82) | typedef typename _Ht::const_pointer const_pointer;
type typename (line 83) | typedef typename _Ht::reference reference;
type typename (line 84) | typedef typename _Ht::const_reference const_reference;
type typename (line 86) | typedef typename _Ht::iterator iterator;
type typename (line 87) | typedef typename _Ht::const_iterator const_iterator;
type typename (line 89) | typedef typename _Ht::allocator_type allocator_type;
function explicit (line 97) | explicit hash_map(size_type __n)
function swap (line 164) | void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }
function iterator (line 176) | iterator begin() { return _M_ht.begin(); }
function iterator (line 177) | iterator end() { return _M_ht.end(); }
function insert (line 189) | void insert(const value_type* __f, const value_type* __l) {
function insert (line 192) | void insert(const_iterator __f, const_iterator __l)
function iterator (line 198) | iterator find(const key_type& __key) { return _M_ht.find(__key); }
function const_iterator (line 199) | const_iterator find(const key_type& __key) const
function size_type (line 206) | size_type count(const key_type& __key) const { return _M_ht.count(__key); }
function size_type (line 214) | size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
function erase (line 215) | void erase(iterator __it) { _M_ht.erase(__it); }
function erase (line 216) | void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
function clear (line 217) | void clear() { _M_ht.clear(); }
function resize (line 219) | void resize(size_type __hint) { _M_ht.resize(__hint); }
function size_type (line 222) | size_type elems_in_bucket(size_type __n) const
type _Tp (line 285) | typedef _Tp data_type;
type _Tp (line 286) | typedef _Tp mapped_type;
type typename (line 287) | typedef typename _Ht::value_type value_type;
type typename (line 288) | typedef typename _Ht::hasher hasher;
type typename (line 289) | typedef typename _Ht::key_equal key_equal;
type typename (line 291) | typedef typename _Ht::size_type size_type;
type typename (line 292) | typedef typename _Ht::difference_type difference_type;
type typename (line 293) | typedef typename _Ht::pointer pointer;
type typename (line 294) | typedef typename _Ht::const_pointer const_pointer;
type typename (line 295) | typedef typename _Ht::reference reference;
type typename (line 296) | typedef typename _Ht::const_reference const_reference;
type typename (line 298) | typedef typename _Ht::iterator iterator;
type typename (line 299) | typedef typename _Ht::const_iterator const_iterator;
type typename (line 301) | typedef typename _Ht::allocator_type allocator_type;
function explicit (line 309) | explicit hash_multimap(size_type __n)
function swap (line 376) | void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }
function iterator (line 387) | iterator begin() { return _M_ht.begin(); }
function iterator (line 388) | iterator end() { return _M_ht.end(); }
function insert (line 400) | void insert(const value_type* __f, const value_type* __l) {
function insert (line 403) | void insert(const_iterator __f, const_iterator __l)
function iterator (line 406) | iterator insert_noresize(const value_type& __obj)
function iterator (line 409) | iterator find(const key_type& __key) { return _M_ht.find(__key); }
function const_iterator (line 410) | const_iterator find(const key_type& __key) const
function size_type (line 413) | size_type count(const key_type& __key) const { return _M_ht.count(__key); }
function size_type (line 421) | size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
function erase (line 422) | void erase(iterator __it) { _M_ht.erase(__it); }
function erase (line 423) | void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
function clear (line 424) | void clear() { _M_ht.clear(); }
function size_type (line 430) | size_type elems_in_bucket(size_type __n) const
type output_iterator_tag (line 473) | typedef output_iterator_tag iterator_category;
type value_type (line 474) | typedef void value_type;
type difference_type (line 475) | typedef void difference_type;
type pointer (line 476) | typedef void pointer;
type reference (line 477) | typedef void reference;
type output_iterator_tag (line 500) | typedef output_iterator_tag iterator_category;
type value_type (line 501) | typedef void value_type;
type difference_type (line 502) | typedef void difference_type;
type pointer (line 503) | typedef void pointer;
type reference (line 504) | typedef void reference;
FILE: stl-3.3-source/stl_hash_set.h
type typename (line 72) | typedef typename _Ht::value_type value_type;
type typename (line 73) | typedef typename _Ht::hasher hasher;
type typename (line 74) | typedef typename _Ht::key_equal key_equal;
type typename (line 76) | typedef typename _Ht::size_type size_type;
type typename (line 77) | typedef typename _Ht::difference_type difference_type;
type typename (line 78) | typedef typename _Ht::const_pointer pointer;
type typename (line 79) | typedef typename _Ht::const_pointer const_pointer;
type typename (line 80) | typedef typename _Ht::const_reference reference;
type typename (line 81) | typedef typename _Ht::const_reference const_reference;
type typename (line 83) | typedef typename _Ht::const_iterator iterator;
type typename (line 84) | typedef typename _Ht::const_iterator const_iterator;
type typename (line 86) | typedef typename _Ht::allocator_type allocator_type;
function explicit (line 95) | explicit hash_set(size_type __n)
function swap (line 162) | void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
function insert (line 187) | void insert(const value_type* __f, const value_type* __l) {
function insert (line 190) | void insert(const_iterator __f, const_iterator __l)
function iterator (line 200) | iterator find(const key_type& __key) const { return _M_ht.find(__key); }
function size_type (line 202) | size_type count(const key_type& __key) const { return _M_ht.count(__key); }
function size_type (line 207) | size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
function erase (line 208) | void erase(iterator __it) { _M_ht.erase(__it); }
function erase (line 209) | void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
function clear (line 210) | void clear() { _M_ht.clear(); }
function size_type (line 216) | size_type elems_in_bucket(size_type __n) const
type typename (line 276) | typedef typename _Ht::value_type value_type;
type typename (line 277) | typedef typename _Ht::hasher hasher;
type typename (line 278) | typedef typename _Ht::key_equal key_equal;
type typename (line 280) | typedef typename _Ht::size_type size_type;
type typename (line 281) | typedef typename _Ht::difference_type difference_type;
type typename (line 282) | typedef typename _Ht::const_pointer pointer;
type typename (line 283) | typedef typename _Ht::const_pointer const_pointer;
type typename (line 284) | typedef typename _Ht::const_reference reference;
type typename (line 285) | typedef typename _Ht::const_reference const_reference;
type typename (line 287) | typedef typename _Ht::const_iterator iterator;
type typename (line 288) | typedef typename _Ht::const_iterator const_iterator;
type typename (line 290) | typedef typename _Ht::allocator_type allocator_type;
function explicit (line 299) | explicit hash_multiset(size_type __n)
function swap (line 366) | void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
function insert (line 388) | void insert(const value_type* __f, const value_type* __l) {
function insert (line 391) | void insert(const_iterator __f, const_iterator __l)
function iterator (line 394) | iterator insert_noresize(const value_type& __obj)
function iterator (line 397) | iterator find(const key_type& __key) const { return _M_ht.find(__key); }
function size_type (line 399) | size_type count(const key_type& __key) const { return _M_ht.count(__key); }
function size_type (line 404) | size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
function erase (line 405) | void erase(iterator __it) { _M_ht.erase(__it); }
function erase (line 406) | void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
function clear (line 407) | void clear() { _M_ht.clear(); }
function size_type (line 413) | size_type elems_in_bucket(size_type __n) const
type output_iterator_tag (line 455) | typedef output_iterator_tag iterator_category;
type value_type (line 456) | typedef void value_type;
type difference_type (line 457) | typedef void difference_type;
type pointer (line 458) | typedef void pointer;
type reference (line 459) | typedef void reference;
type output_iterator_tag (line 482) | typedef output_iterator_tag iterator_category;
type value_type (line 483) | typedef void value_type;
type difference_type (line 484) | typedef void difference_type;
type pointer (line 485) | typedef void pointer;
type reference (line 486) | typedef void reference;
FILE: stl-3.3-source/stl_hashtable.h
function __STL_BEGIN_NAMESPACE (line 47) | __STL_BEGIN_NAMESPACE
type _Hashtable_iterator (line 73) | typedef _Hashtable_iterator<_Val, _Key, _HashFcn,
type _Hashtable_const_iterator (line 76) | typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
type _Hashtable_node (line 79) | typedef _Hashtable_node<_Val> _Node;
type forward_iterator_tag (line 81) | typedef forward_iterator_tag iterator_category;
type _Val (line 82) | typedef _Val value_type;
type difference_type (line 83) | typedef ptrdiff_t difference_type;
type size_type (line 84) | typedef size_t size_type;
type _Val (line 85) | typedef _Val& reference;
type _Val (line 86) | typedef _Val* pointer;
function reference (line 94) | reference operator*() const { return _M_cur->_M_val; }
function pointer (line 96) | pointer operator->() const { return &(operator*()); }
type _Hashtable_iterator (line 112) | typedef _Hashtable_iterator<_Val,_Key,_HashFcn,
type _Hashtable_const_iterator (line 115) | typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
type _Hashtable_node (line 118) | typedef _Hashtable_node<_Val> _Node;
type forward_iterator_tag (line 120) | typedef forward_iterator_tag iterator_category;
type _Val (line 121) | typedef _Val value_type;
type difference_type (line 122) | typedef ptrdiff_t difference_type;
type size_type (line 123) | typedef size_t size_type;
type _Val (line 124) | typedef const _Val& reference;
type _Val (line 125) | typedef const _Val* pointer;
function pointer (line 137) | pointer operator->() const { return &(operator*()); }
function __stl_next_prime (line 160) | inline unsigned long __stl_next_prime(unsigned long __n)
type _Val (line 191) | typedef _Val value_type;
type _HashFcn (line 192) | typedef _HashFcn hasher;
type _EqualKey (line 193) | typedef _EqualKey key_equal;
type size_type (line 195) | typedef size_t size_type;
type difference_type (line 196) | typedef ptrdiff_t difference_type;
type value_type (line 197) | typedef value_type* pointer;
type value_type (line 198) | typedef const value_type* const_pointer;
type value_type (line 199) | typedef value_type& reference;
type value_type (line 200) | typedef const value_type& const_reference;
function _Node (line 214) | _Node* _M_get_node() { return _M_node_allocator.allocate(1); }
function _M_put_node (line 215) | void _M_put_node(_Node* __p) { _M_node_allocator.deallocate(__p, 1); }
function _Node (line 223) | _Node* _M_get_node() { return _M_node_allocator_type::allocate(1); }
function _M_put_node (line 224) | void _M_put_node(_Node* __p) { _M_node_allocator_type::deallocate(__p, 1...
type _Hashtable_const_iterator (line 238) | typedef _Hashtable_const_iterator<_Val,_Key,_HashFcn,_ExtractKey,_EqualKey,
function swap (line 308) | void swap(hashtable& __ht)
function iterator (line 317) | iterator begin()
function iterator (line 325) | iterator end() { return iterator(0, this); }
function size_type (line 353) | size_type elems_in_bucket(size_type __bucket) const
function iterator (line 367) | iterator insert_equal(const value_type& __obj)
function insert_unique (line 428) | void insert_unique(const value_type* __f, const value_type* __l)
function insert_equal (line 436) | void insert_equal(const value_type* __f, const value_type* __l)
function insert_unique (line 444) | void insert_unique(const_iterator __f, const_iterator __l)
function insert_equal (line 453) | void insert_equal(const_iterator __f, const_iterator __l)
function iterator (line 465) | iterator find(const key_type& __key)
function const_iterator (line 476) | const_iterator find(const key_type& __key) const
function size_type (line 487) | size_type count(const key_type& __key) const
function _M_initialize_buckets (line 518) | void _M_initialize_buckets(size_type __n)
function size_type (line 526) | size_type _M_bkt_num_key(const key_type& __key) const
function size_type (line 531) | size_type _M_bkt_num(const value_type& __obj) const
function size_type (line 536) | size_type _M_bkt_num_key(const key_type& __key, size_t __n) const
function size_type (line 541) | size_type _M_bkt_num(const value_type& __obj, size_t __n) const
function _Node (line 546) | _Node* _M_new_node(const value_type& __obj)
function _M_delete_node (line 557) | void _M_delete_node(_Node* __n)
FILE: stl-3.3-source/stl_heap.h
function __push_heap_aux (line 56) | void
function push_heap (line 65) | void
function __push_heap_aux (line 92) | void
function push_heap (line 102) | void
function __pop_heap (line 133) | void
function __pop_heap_aux (line 142) | void
function pop_heap (line 151) | void pop_heap(_RandomAccessIterator __first,
function __pop_heap (line 184) | void
function __pop_heap_aux (line 195) | void
function pop_heap (line 204) | void
FILE: stl-3.3-source/stl_iterator.h
type output_iterator_tag (line 43) | typedef output_iterator_tag iterator_category;
type value_type (line 44) | typedef void value_type;
type difference_type (line 45) | typedef void difference_type;
type pointer (line 46) | typedef void pointer;
type reference (line 47) | typedef void reference;
function explicit (line 49) | explicit back_insert_iterator(_Container& __x) : container(&__x) {}
type output_iterator_tag (line 82) | typedef output_iterator_tag iterator_category;
type value_type (line 83) | typedef void value_type;
type difference_type (line 84) | typedef void difference_type;
type pointer (line 85) | typedef void pointer;
type reference (line 86) | typedef void reference;
function explicit (line 88) | explicit front_insert_iterator(_Container& __x) : container(&__x) {}
type output_iterator_tag (line 122) | typedef output_iterator_tag iterator_category;
type value_type (line 123) | typedef void value_type;
type difference_type (line 124) | typedef void difference_type;
type pointer (line 125) | typedef void pointer;
type reference (line 126) | typedef void reference;
type typename (line 156) | typedef typename _Container::iterator __iter;
type reverse_bidirectional_iterator (line 168) | typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
type _Tp (line 174) | typedef _Tp value_type;
type _Distance (line 175) | typedef _Distance difference_type;
type _Tp (line 176) | typedef _Tp* pointer;
type _Reference (line 177) | typedef _Reference reference;
function explicit (line 180) | explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
function _Reference (line 183) | _Reference operator*() const {
function pointer (line 188) | pointer operator->() const { return &(operator*()); }
FILE: stl-3.3-source/stl_iterator_base.h
function __STL_BEGIN_NAMESPACE (line 40) | __STL_BEGIN_NAMESPACE
type output_iterator_tag (line 43) | struct output_iterator_tag {}
function input_iterator_tag (line 44) | struct forward_iterator_tag : public input_iterator_tag {}
function forward_iterator_tag (line 45) | struct bidirectional_iterator_tag : public forward_iterator_tag {}
function bidirectional_iterator_tag (line 46) | struct random_access_iterator_tag : public bidirectional_iterator_tag {}
type input_iterator_tag (line 54) | typedef input_iterator_tag iterator_category;
type _Tp (line 55) | typedef _Tp value_type;
type _Distance (line 56) | typedef _Distance difference_type;
type _Tp (line 57) | typedef _Tp* pointer;
type _Tp (line 58) | typedef _Tp& reference;
type output_iterator (line 61) | struct output_iterator {
type forward_iterator_tag (line 70) | typedef forward_iterator_tag iterator_category;
type _Tp (line 71) | typedef _Tp value_type;
type _Distance (line 72) | typedef _Distance difference_type;
type _Tp (line 73) | typedef _Tp* pointer;
type _Tp (line 74) | typedef _Tp& reference;
type bidirectional_iterator_tag (line 79) | typedef bidirectional_iterator_tag iterator_category;
type _Tp (line 80) | typedef _Tp value_type;
type _Distance (line 81) | typedef _Distance difference_type;
type _Tp (line 82) | typedef _Tp* pointer;
type _Tp (line 83) | typedef _Tp& reference;
type random_access_iterator_tag (line 87) | typedef random_access_iterator_tag iterator_category;
type _Tp (line 88) | typedef _Tp value_type;
type _Distance (line 89) | typedef _Distance difference_type;
type _Tp (line 90) | typedef _Tp* pointer;
type _Tp (line 91) | typedef _Tp& reference;
type _Category (line 98) | typedef _Category iterator_category;
type _Tp (line 99) | typedef _Tp value_type;
type _Distance (line 100) | typedef _Distance difference_type;
type _Pointer (line 101) | typedef _Pointer pointer;
type _Reference (line 102) | typedef _Reference reference;
type typename (line 110) | typedef typename _Iterator::iterator_category iterator_category;
type typename (line 111) | typedef typename _Iterator::value_type value_type;
type typename (line 112) | typedef typename _Iterator::difference_type difference_type;
type typename (line 113) | typedef typename _Iterator::pointer pointer;
type typename (line 114) | typedef typename _Iterator::reference reference;
type random_access_iterator_tag (line 119) | typedef random_access_iterator_tag iterator_category;
type _Tp (line 120) | typedef _Tp value_type;
type difference_type (line 121) | typedef ptrdiff_t difference_type;
type _Tp (line 122) | typedef _Tp* pointer;
type _Tp (line 123) | typedef _Tp& reference;
type random_access_iterator_tag (line 128) | typedef random_access_iterator_tag iterator_category;
type _Tp (line 129) | typedef _Tp value_type;
type difference_type (line 130) | typedef ptrdiff_t difference_type;
type _Tp (line 131) | typedef const _Tp* pointer;
type _Tp (line 132) | typedef const _Tp& reference;
type typename (line 146) | typedef typename iterator_traits<_Iter>::iterator_category _Category;
FILE: stl-3.3-source/stl_list.h
type _List_node_base (line 43) | struct _List_node_base {
function _M_decr (line 53) | struct _List_iterator_base {
type _List_iterator (line 76) | typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
type _List_iterator (line 77) | typedef _List_iterator<_Tp,const
type _List_iterator (line 78) | typedef _List_iterator<_Tp,_Ref,_Ptr> _Self;
type _Tp (line 80) | typedef _Tp value_type;
type _Ptr (line 81) | typedef _Ptr pointer;
type _Ref (line 82) | typedef _Ref reference;
type _List_node (line 83) | typedef _List_node<_Tp> _Node;
function _List_iterator_base (line 85) | _List_iterator_base(__x) {}
function _List_iterator_base (line 87) | _List_iterator(const iterator& __x) : _List_iterator_base(__x._M_node) {}
function reference (line 89) | reference operator*() const { return ((_Node*) _M_node)->_M_data; }
function pointer (line 92) | pointer operator->() const { return &(operator*()); }
function bidirectional_iterator_tag (line 117) | inline bidirectional_iterator_tag
function _Tp (line 124) | _Tp*
function _Node_allocator (line 156) | _List_alloc_base(const allocator_type& __a) : _Node_allocator(__a) {}
function _M_put_node (line 161) | void _M_put_node(_List_node<_Tp>* __p)
type typename (line 175) | typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
function _M_put_node (line 185) | void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
type typename (line 200) | typedef typename _Base::allocator_type allocator_type;
function _Base (line 202) | _List_base(const allocator_type& __a) : _Base(__a) {
function _M_put_node (line 239) | void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }
type _List_base (line 268) | typedef _List_base<_Tp, _Alloc> _Base;
type value_type (line 274) | typedef value_type* pointer;
type value_type (line 275) | typedef const value_type* const_pointer;
type value_type (line 276) | typedef value_type& reference;
type value_type (line 277) | typedef const value_type& const_reference;
type _List_node (line 278) | typedef _List_node<_Tp> _Node;
type size_type (line 279) | typedef size_t size_type;
type difference_type (line 280) | typedef ptrdiff_t difference_type;
type typename (line 282) | typedef typename _Base::allocator_type allocator_type;
function allocator_type (line 283) | allocator_type get_allocator() const { return _Base::get_allocator(); }
function _Node (line 319) | _Node* _M_create_node()
function iterator (line 332) | iterator begin() { return (_Node*)(_M_node->_M_next); }
function iterator (line 335) | iterator end() { return _M_node; }
function reverse_iterator (line 338) | reverse_iterator rbegin()
function const_reverse_iterator (line 340) | const_reverse_iterator rbegin() const
function size_type (line 349) | size_type size() const {
function reference (line 356) | reference front() { return *begin(); }
function reference (line 358) | reference back() { return *(--end()); }
function swap (line 361) | void swap(list<_Tp, _Alloc>& __x) { __STD::swap(_M_node, __x._M_node); }
function iterator (line 363) | iterator insert(iterator __position, const _Tp& __x) {
function iterator (line 371) | iterator insert(iterator __position) { return insert(__position, _Tp()); }
type typename (line 388) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function insert (line 397) | void insert(iterator __pos, size_type __n, const _Tp& __x)
function push_front (line 401) | void push_front(const _Tp& __x) { insert(begin(), __x); }
function push_front (line 402) | void push_front() {insert(begin());}
function push_back (line 403) | void push_back(const _Tp& __x) { insert(end(), __x); }
function push_back (line 404) | void push_back() {insert(end());}
function iterator (line 406) | iterator erase(iterator __position) {
function clear (line 417) | void clear() { _Base::clear(); }
function resize (line 420) | void resize(size_type __new_size) { this->resize(__new_size, _Tp()); }
function pop_front (line 422) | void pop_front() { erase(begin()); }
function pop_back (line 423) | void pop_back() {
function explicit (line 431) | explicit list(size_type __n)
function _Base (line 442) | _Base(__a)
type typename (line 478) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function splice (line 513) | void splice(iterator __position, list&, iterator __i) {
function splice (line 519) | void splice(iterator __position, list&, iterator __first, iterator __las...
type typename (line 541) | typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
function __List_base_reverse (line 757) | inline void __List_base_reverse(_List_node_base* __p)
FILE: stl-3.3-source/stl_map.h
type _Key (line 68) | typedef _Key key_type;
type _Tp (line 69) | typedef _Tp data_type;
type _Tp (line 70) | typedef _Tp mapped_type;
type pair (line 71) | typedef pair<const _Key, _Tp> value_type;
type _Compare (line 72) | typedef _Compare key_compare;
function comp (line 79) | value_compare(_Compare __c) : comp(__c) {}
type typename (line 92) | typedef typename _Rep_type::const_pointer const_pointer;
type typename (line 93) | typedef typename _Rep_type::reference reference;
type typename (line 94) | typedef typename _Rep_type::const_reference const_reference;
type typename (line 95) | typedef typename _Rep_type::iterator iterator;
type typename (line 96) | typedef typename _Rep_type::const_iterator const_iterator;
type typename (line 97) | typedef typename _Rep_type::reverse_iterator reverse_iterator;
type typename (line 98) | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
type typename (line 99) | typedef typename _Rep_type::size_type size_type;
type typename (line 100) | typedef typename _Rep_type::difference_type difference_type;
type typename (line 101) | typedef typename _Rep_type::allocator_type allocator_type;
function explicit (line 106) | explicit map(const _Compare& __comp,
function iterator (line 154) | iterator begin() { return _M_t.begin(); }
function iterator (line 156) | iterator end() { return _M_t.end(); }
function reverse_iterator (line 158) | reverse_iterator rbegin() { return _M_t.rbegin(); }
function reverse_iterator (line 160) | reverse_iterator rend() { return _M_t.rend(); }
function swap (line 172) | void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
function iterator (line 178) | iterator insert(iterator position, const value_type& __x)
function insert (line 186) | void insert(const value_type* __first, const value_type* __last) {
function insert (line 189) | void insert(const_iterator __first, const_iterator __last) {
function erase (line 194) | void erase(iterator __position) { _M_t.erase(__position); }
function size_type (line 195) | size_type erase(const key_type& __x) { return _M_t.erase(__x); }
function erase (line 196) | void erase(iterator __first, iterator __last)
function clear (line 198) | void clear() { _M_t.clear(); }
function iterator (line 202) | iterator find(const key_type& __x) { return _M_t.find(__x); }
function const_iterator (line 203) | const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
function size_type (line 204) | size_type count(const key_type& __x) const {
function iterator (line 207) | iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
function const_iterator (line 208) | const_iterator lower_bound(const key_type& __x) const {
function iterator (line 211) | iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
function const_iterator (line 212) | const_iterator upper_bound(const key_type& __x) const {
FILE: stl-3.3-source/stl_multimap.h
type _Tp (line 70) | typedef _Tp data_type;
type _Tp (line 71) | typedef _Tp mapped_type;
type pair (line 72) | typedef pair<const _Key, _Tp> value_type;
type _Compare (line 73) | typedef _Compare key_compare;
function comp (line 79) | value_compare(_Compare __c) : comp(__c) {}
type typename (line 92) | typedef typename _Rep_type::const_pointer const_pointer;
type typename (line 93) | typedef typename _Rep_type::reference reference;
type typename (line 94) | typedef typename _Rep_type::const_reference const_reference;
type typename (line 95) | typedef typename _Rep_type::iterator iterator;
type typename (line 96) | typedef typename _Rep_type::const_iterator const_iterator;
type typename (line 97) | typedef typename _Rep_type::reverse_iterator reverse_iterator;
type typename (line 98) | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
type typename (line 99) | typedef typename _Rep_type::size_type size_type;
type typename (line 100) | typedef typename _Rep_type::difference_type difference_type;
type typename (line 101) | typedef typename _Rep_type::allocator_type allocator_type;
function explicit (line 106) | explicit multimap(const _Compare& __comp,
function iterator (line 152) | iterator begin() { return _M_t.begin(); }
function iterator (line 154) | iterator end() { return _M_t.end(); }
function reverse_iterator (line 156) | reverse_iterator rbegin() { return _M_t.rbegin(); }
function reverse_iterator (line 158) | reverse_iterator rend() { return _M_t.rend(); }
function swap (line 163) | void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
function iterator (line 167) | iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
function iterator (line 168) | iterator insert(iterator __position, const value_type& __x) {
function insert (line 177) | void insert(const value_type* __first, const value_type* __last) {
function insert (line 180) | void insert(const_iterator __first, const_iterator __last) {
function erase (line 184) | void erase(iterator __position) { _M_t.erase(__position); }
function size_type (line 185) | size_type erase(const key_type& __x) { return _M_t.erase(__x); }
function erase (line 186) | void erase(iterator __first, iterator __last)
function clear (line 188) | void clear() { _M_t.clear(); }
function iterator (line 192) | iterator find(const key_type& __x) { return _M_t.find(__x); }
function const_iterator (line 193) | const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
function size_type (line 194) | size_type count(const key_type& __x) const { return _M_t.count(__x); }
function iterator (line 195) | iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
function const_iterator (line 196) | const_iterator lower_bound(const key_type& __x) const {
function iterator (line 199) | iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
function const_iterator (line 200) | const_iterator upper_bound(const key_type& __x) const {
FILE: stl-3.3-source/stl_multiset.h
type _Key (line 69) | typedef _Key value_type;
type _Compare (line 70) | typedef _Compare key_compare;
type _Compare (line 71) | typedef _Compare value_compare;
type typename (line 78) | typedef typename _Rep_type::const_pointer const_pointer;
type typename (line 79) | typedef typename _Rep_type::const_reference reference;
type typename (line 80) | typedef typename _Rep_type::const_reference const_reference;
type typename (line 81) | typedef typename _Rep_type::const_iterator iterator;
type typename (line 82) | typedef typename _Rep_type::const_iterator const_iterator;
type typename (line 83) | typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
type typename (line 84) | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
type typename (line 85) | typedef typename _Rep_type::size_type size_type;
type typename (line 86) | typedef typename _Rep_type::difference_type difference_type;
type typename (line 87) | typedef typename _Rep_type::allocator_type allocator_type;
function explicit (line 92) | explicit multiset(const _Compare& __comp,
function swap (line 151) | void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
function iterator (line 154) | iterator insert(const value_type& __x) {
function iterator (line 157) | iterator insert(iterator __position, const value_type& __x) {
function insert (line 168) | void insert(const value_type* __first, const value_type* __last) {
function insert (line 171) | void insert(const_iterator __first, const_iterator __last) {
function erase (line 175) | void erase(iterator __position) {
function size_type (line 179) | size_type erase(const key_type& __x) {
function erase (line 182) | void erase(iterator __first, iterator __last) {
function clear (line 186) | void clear() { _M_t.clear(); }
function iterator (line 190) | iterator find(const key_type& __x) const { return _M_t.find(__x); }
function size_type (line 191) | size_type count(const key_type& __x) const { return _M_t.count(__x); }
function iterator (line 192) | iterator lower_bound(const key_type& __x) const {
function iterator (line 195) | iterator upper_bound(const key_type& __x) const {
FILE: stl-3.3-source/stl_numeric.h
function _Tp (line 217) | _Tp __power(_Tp __x, _Integer __n)
function _Tp (line 226) | _Tp power(_Tp __x, _Integer __n, _MonoidOperation __opr)
function _Tp (line 232) | _Tp power(_Tp __x, _Integer __n)
FILE: stl-3.3-source/stl_pair.h
type pair (line 37) | struct pair {
FILE: stl-3.3-source/stl_queue.h
type typename (line 59) | typedef typename _Sequence::value_type _Sequence_value_type;
type typename (line 79) | typedef typename _Sequence::size_type size_type;
type _Sequence (line 80) | typedef _Sequence container_type;
type typename (line 82) | typedef typename _Sequence::reference reference;
type typename (line 83) | typedef typename _Sequence::const_reference const_reference;
function explicit (line 88) | explicit queue(const _Sequence& __c) : c(__c) {}
function reference (line 92) | reference front() { return c.front(); }
function reference (line 94) | reference back() { return c.back(); }
function push (line 96) | void push(const value_type& __x) { c.push_back(__x); }
function pop (line 97) | void pop() { c.pop_front(); }
type typename (line 157) | typedef typename _Sequence::value_type _Sequence_value_type;
type typename (line 163) | typedef typename _Sequence::size_type size_type;
type _Sequence (line 164) | typedef _Sequence container_type;
type typename (line 166) | typedef typename _Sequence::reference reference;
type typename (line 167) | typedef typename _Sequence::const_reference const_reference;
function explicit (line 173) | explicit priority_queue(const _Compare& __x) : c(), comp(__x) {}
function push (line 219) | void push(const value_type& __x) {
function pop (line 226) | void pop() {
FILE: stl-3.3-source/stl_range_errors.h
function __STL_BEGIN_NAMESPACE (line 50) | __STL_BEGIN_NAMESPACE
function __stl_throw_length_error (line 53) | inline void __stl_throw_length_error(const char* __msg)
function __STL_BEGIN_NAMESPACE (line 60) | __STL_BEGIN_NAMESPACE
function __stl_throw_length_error (line 62) | inline void __stl_throw_length_error(const char*) {}
FILE: stl-3.3-source/stl_raw_storage_iter.h
type value_type (line 42) | typedef void value_type;
type difference_type (line 43) | typedef void difference_type;
type pointer (line 44) | typedef void pointer;
type reference (line 45) | typedef void reference;
function explicit (line 47) | explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
FILE: stl-3.3-source/stl_rope.h
function _CharT (line 49) | _CharT _S_eos(_CharT*) { return _CharT(); }
function _S_is_basic_char_type (line 54) | bool _S_is_basic_char_type(_CharT*) { return false; }
function _S_is_one_byte_char_type (line 56) | bool _S_is_one_byte_char_type(_CharT*) { return false; }
function _S_is_basic_char_type (line 58) | inline bool _S_is_basic_char_type(char*) { return true; }
function _S_is_one_byte_char_type (line 59) | inline bool _S_is_one_byte_char_type(char*) { return true; }
function _S_is_basic_char_type (line 60) | inline bool _S_is_basic_char_type(wchar_t*) { return true; }
type typename (line 110) | typedef typename _Sequence::value_type value_type;
type _V (line 112) | typedef _V value_type;
function push_back (line 148) | void push_back(value_type __x)
function append (line 159) | void append(value_type* __s, size_t __len)
type typename (line 413) | typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
type typename (line 443) | typedef typename _Base::allocator_type allocator_type;
function allocator_type (line 456) | static allocator_type get_allocator() { return allocator_type(); }
type _Tag (line 483) | enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function}
type typename (line 494) | typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
function _M_unref_nonnil (line 525) | void _M_unref_nonnil()
function _M_ref_nonnil (line 529) | void _M_ref_nonnil()
function _S_unref (line 533) | static void _S_unref(_Rope_RopeRep* __t)
function _S_ref (line 539) | static void _S_ref(_Rope_RopeRep* __t)
function _S_free_if_unref (line 543) | static void _S_free_if_unref(_Rope_RopeRep* __t)
function _M_unref_nonnil (line 548) | void _M_unref_nonnil() {}
function _M_ref_nonnil (line 549) | void _M_ref_nonnil() {}
function _S_unref (line 550) | static void _S_unref(_Rope_RopeRep*) {}
function _S_ref (line 551) | static void _S_ref(_Rope_RopeRep*) {}
function _S_free_if_unref (line 552) | static void _S_free_if_unref(_Rope_RopeRep*) {}
function _S_rounded_up_size (line 565) | static size_t _S_rounded_up_size(size_t __n) {
type typename (line 586) | typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
type typename (line 616) | typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
function _S_fn_finalization_proc (line 652) | static void _S_fn_finalization_proc(void * __tree, void *) {
type typename (line 656) | typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
function virtual (line 697) | virtual void operator()(size_t __start_pos, size_t __req_len,
type typename (line 722) | typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
function virtual (line 738) | virtual ~_Rope_RopeSubstring()
function _M_ptr (line 768) | _M_ptr(__p) {}
type _Rope_RopeRep (line 788) | typedef _Rope_RopeRep<_CharT,_Alloc>* _Self_destruct_ptr;
type _Rope_self_destruct_ptr (line 790) | typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
type _Rope_RopeRep (line 792) | typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
type rope (line 793) | typedef rope<_CharT,_Alloc> _My_rope;
type _Rope_RopeRep (line 899) | typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
type _Rope_RopeRep (line 970) | typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
type _CharT (line 982) | typedef const _CharT* pointer;
function reference (line 1001) | reference operator*() {
function reference (line 1073) | reference operator[](size_t __n) {
type _Rope_char_ref_proxy (line 1123) | typedef _Rope_char_ref_proxy<_CharT,_Alloc>* pointer;
function reference (line 1155) | reference operator*() {
function reference (line 1199) | reference operator[](ptrdiff_t __n) {
type typename (line 1266) | typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
function _M_data_allocator (line 1271) | _Rope_alloc_base(const allocator_type& __a)
type typename (line 1296) | typedef typename _Alloc_traits<_CharT,_Allocator>::allocator_type
type typename (line 1328) | typedef typename _Base::allocator_type allocator_type;
type _Rope_RopeRep (line 1329) | typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
function _Base (line 1332) | _Rope_base(const allocator_type& __a) : _Base(__a) {}
type _Alloc (line 1341) | typedef _Alloc allocator_type;
function allocator_type (line 1342) | static allocator_type get_allocator() { return allocator_type(); }
type difference_type (line 1367) | typedef ptrdiff_t difference_type;
type size_type (line 1368) | typedef size_t size_type;
type _CharT (line 1369) | typedef _CharT const_reference;
type _CharT (line 1370) | typedef const _CharT* const_pointer;
type _Rope_iterator (line 1371) | typedef _Rope_iterator<_CharT,_Alloc> iterator;
type _Rope_const_iterator (line 1372) | typedef _Rope_const_iterator<_CharT,_Alloc> const_iterator;
type _Rope_char_ref_proxy (line 1373) | typedef _Rope_char_ref_proxy<_CharT,_Alloc> reference;
type _Rope_char_ptr_proxy (line 1374) | typedef _Rope_char_ptr_proxy<_CharT,_Alloc> pointer;
type typename (line 1386) | typedef typename _Base::allocator_type allocator_type;
type __GC_CONST (line 1390) | typedef __GC_CONST _CharT* _Cstrptr;
function _S_is0 (line 1394) | static bool _S_is0(_CharT __c) { return __c == _S_eos((_CharT*)0); }
type _Rope_RopeRep (line 1399) | typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
type _Rope_RopeConcatenation (line 1400) | typedef _Rope_RopeConcatenation<_CharT,_Alloc> _RopeConcatenation;
type _Rope_RopeLeaf (line 1401) | typedef _Rope_RopeLeaf<_CharT,_Alloc> _RopeLeaf;
type _Rope_RopeFunction (line 1402) | typedef _Rope_RopeFunction<_CharT,_Alloc> _RopeFunction;
type _Rope_RopeSubstring (line 1403) | typedef _Rope_RopeSubstring<_CharT,_Alloc> _RopeSubstring;
function _S_unref (line 1426) | static void _S_unref(_RopeRep* __t)
function _S_ref (line 1430) | static void _S_ref(_RopeRep* __t)
function _S_unref (line 1435) | static void _S_unref(_RopeRep*) {}
function _S_ref (line 1436) | static void _S_ref(_RopeRep*) {}
type _Rope_RopeRep (line 1441) | typedef _Rope_RopeRep<_CharT,_Alloc>* _Self_destruct_ptr;
type _Rope_self_destruct_ptr (line 1443) | typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
function _S_allocated_capacity (line 1484) | static size_t _S_allocated_capacity(size_t __n) {
function _RopeLeaf (line 1494) | static _RopeLeaf* _S_new_RopeLeaf(__GC_CONST _CharT *__s,
function _RopeConcatenation (line 1505) | static _RopeConcatenation* _S_new_RopeConcatenation(
function _RopeFunction (line 1517) | static _RopeFunction* _S_new_RopeFunction(char_producer<_CharT>* __f,
function _RopeSubstring (line 1528) | static _RopeSubstring* _S_new_RopeSubstring(
function _S_is_balanced (line 1616) | static bool _S_is_balanced(_RopeRep* __r)
function _S_is_almost_balanced (line 1619) | static bool _S_is_almost_balanced(_RopeRep* __r)
function _S_is_roughly_balanced (line 1623) | static bool _S_is_roughly_balanced(_RopeRep* __r)
function _RopeRep (line 1628) | static _RopeRep* _S_concat_and_set_balanced(_RopeRep* __left,
function compare (line 1662) | int compare(const rope& __y) const {
function _Base (line 1717) | _Base(__a)
function clear (line 1746) | void clear()
function push_back (line 1752) | void push_back(_CharT __x)
function pop_back (line 1759) | void pop_back()
function push_front (line 1772) | void push_front(_CharT __x)
function pop_front (line 1785) | void pop_front()
function balance (line 1797) | void balance()
function copy (line 1804) | void copy(_CharT* __buffer) const {
function size_type (line 1814) | size_type copy(size_type __pos, size_type __n, _CharT* __buffer) const
function dump (line 1826) | void dump() {
function delete_c_str (line 1841) | void delete_c_str () {
function _CharT (line 1855) | _CharT operator[] (size_type __pos) const {
function _CharT (line 1859) | _CharT at(size_type __pos) const {
type reverse_iterator (line 1897) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 1899) | typedef reverse_iterator<const_iterator, value_type, const_reference,
function swap (line 2013) | void swap(rope& __b) {
function insert (line 2057) | void insert(size_t __p, size_t __n, _CharT __c) {
function insert (line 2062) | void insert(size_t __p, const _CharT* __i, size_t __n) {
function insert (line 2075) | void insert(size_t __p, const _CharT* __c_string) {
function insert (line 2079) | void insert(size_t __p, _CharT __c) {
function insert (line 2083) | void insert(size_t __p) {
function insert (line 2088) | void insert(size_t __p, const _CharT* __i, const _CharT* __j) {
function insert (line 2093) | void insert(size_t __p, const const_iterator& __i,
function insert (line 2099) | void insert(size_t __p, const iterator& __i,
function replace (line 2107) | void replace(size_t __p, size_t __n, const rope& __r) {
function replace (line 2114) | void replace(size_t __p, size_t __n,
function replace (line 2120) | void replace(size_t __p, size_t __n, _CharT __c) {
function replace (line 2125) | void replace(size_t __p, size_t __n, const _CharT* __c_string) {
function replace (line 2130) | void replace(size_t __p, size_t __n,
function replace (line 2136) | void replace(size_t __p, size_t __n,
function replace (line 2142) | void replace(size_t __p, size_t __n,
function replace (line 2149) | void replace(size_t __p, _CharT __c) {
function replace (line 2154) | void replace(size_t __p, const rope& __r) {
function replace (line 2158) | void replace(size_t __p, const _CharT* __i, size_t __i_len) {
function replace (line 2162) | void replace(size_t __p, const _CharT* __c_string) {
function replace (line 2166) | void replace(size_t __p, const _CharT* __i, const _CharT* __j) {
function replace (line 2170) | void replace(size_t __p, const const_iterator& __i,
function replace (line 2175) | void replace(size_t __p, const iterator& __i,
function erase (line 2181) | void erase(size_t __p, size_t __n) {
function erase (line 2188) | void erase(size_t __p) {
function iterator (line 2193) | iterator insert(const iterator& __p, const rope& __r)
function iterator (line 2195) | iterator insert(const iterator& __p, size_t __n, _CharT __c)
function iterator (line 2197) | iterator insert(const iterator& __p, _CharT __c)
function iterator (line 2199) | iterator insert(const iterator& __p )
function iterator (line 2201) | iterator insert(const iterator& __p, const _CharT* c_string)
function iterator (line 2203) | iterator insert(const iterator& __p, const _CharT* __i, size_t __n)
function iterator (line 2205) | iterator insert(const iterator& __p, const _CharT* __i,
function iterator (line 2208) | iterator insert(const iterator& __p,
function iterator (line 2211) | iterator insert(const iterator& __p,
function replace (line 2216) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2219) | void replace(const iterator& __p, const iterator& __q, _CharT __c)
function replace (line 2221) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2224) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2227) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2230) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2233) | void replace(const iterator& __p, const iterator& __q,
function replace (line 2238) | void replace(const iterator& __p, const rope& __r)
function replace (line 2240) | void replace(const iterator& __p, _CharT __c)
function replace (line 2242) | void replace(const iterator& __p, const _CharT* __c_string)
function replace (line 2244) | void replace(const iterator& __p, const _CharT* __i, size_t __n)
function replace (line 2246) | void replace(const iterator& __p, const _CharT* __i, const _CharT* __j)
function replace (line 2248) | void replace(const iterator& __p, const_iterator __i,
function replace (line 2251) | void replace(const iterator& __p, iterator __i, iterator __j)
function iterator (line 2255) | iterator erase(const iterator& __p, const iterator& __q) {
function iterator (line 2260) | iterator erase(const iterator& __p) {
function rope (line 2271) | rope substr(iterator __start, iterator __end) const {
function rope (line 2276) | rope substr(iterator __start) const {
function rope (line 2282) | rope substr(const_iterator __start, const_iterator __end) const {
function iterator (line 2309) | iterator mutable_begin() {
function iterator (line 2313) | iterator mutable_end() {
type reverse_iterator (line 2318) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 2320) | typedef reverse_iterator<iterator, value_type, reference,
function reverse_iterator (line 2324) | reverse_iterator mutable_rbegin() {
function reverse_iterator (line 2328) | reverse_iterator mutable_rend() {
function reference (line 2332) | reference mutable_reference_at(size_type __pos) {
function reference (line 2337) | reference operator[] (size_type __pos) {
function reference (line 2341) | reference at(size_type __pos) {
function resize (line 2346) | void resize(size_type __n, _CharT __c) {}
function resize (line 2347) | void resize(size_type __n) {}
function iterator (line 2361) | iterator end() { return mutable_end(); }
function iterator (line 2363) | iterator begin() { return mutable_begin(); }
function reverse_iterator (line 2365) | reverse_iterator rend() { return mutable_rend(); }
function reverse_iterator (line 2367) | reverse_iterator rbegin() { return mutable_rbegin(); }
function const_iterator (line 2371) | const_iterator end() { return const_end(); }
function const_iterator (line 2373) | const_iterator begin() { return const_begin(); }
function const_reverse_iterator (line 2375) | const_reverse_iterator rend() { return const_rend(); }
function const_reverse_iterator (line 2377) | const_reverse_iterator rbegin() { return const_rbegin(); }
type rope (line 2651) | typedef rope<char> crope;
type rope (line 2652) | typedef rope<wchar_t> wrope;
function crope (line 2654) | inline crope::reference __mutable_reference_at(crope& __c, size_t __i)
function wrope (line 2659) | inline wrope::reference __mutable_reference_at(wrope& __c, size_t __i)
function swap (line 2673) | inline void swap(crope __x, crope __y) { __x.swap(__y); }
function swap (line 2674) | inline void swap(wrope __x, wrope __y) { __x.swap(__y); }
function const (line 2681) | size_t operator()(const crope& __str) const
function const (line 2693) | size_t operator()(const wrope& __str) const
FILE: stl-3.3-source/stl_set.h
type _Key (line 69) | typedef _Key value_type;
type _Compare (line 70) | typedef _Compare key_compare;
type _Compare (line 71) | typedef _Compare value_compare;
type typename (line 78) | typedef typename _Rep_type::const_pointer const_pointer;
type typename (line 79) | typedef typename _Rep_type::const_reference reference;
type typename (line 80) | typedef typename _Rep_type::const_reference const_reference;
type typename (line 81) | typedef typename _Rep_type::const_iterator iterator;
type typename (line 82) | typedef typename _Rep_type::const_iterator const_iterator;
type typename (line 83) | typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
type typename (line 84) | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
type typename (line 85) | typedef typename _Rep_type::size_type size_type;
type typename (line 86) | typedef typename _Rep_type::difference_type difference_type;
type typename (line 87) | typedef typename _Rep_type::allocator_type allocator_type;
function explicit (line 92) | explicit set(const _Compare& __comp,
function swap (line 145) | void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
function iterator (line 152) | iterator insert(iterator __position, const value_type& __x) {
function insert (line 162) | void insert(const_iterator __first, const_iterator __last) {
function insert (line 165) | void insert(const value_type* __first, const value_type* __last) {
function erase (line 169) | void erase(iterator __position) {
function size_type (line 173) | size_type erase(const key_type& __x) {
function erase (line 176) | void erase(iterator __first, iterator __last) {
function clear (line 180) | void clear() { _M_t.clear(); }
function iterator (line 184) | iterator find(const key_type& __x) const { return _M_t.find(__x); }
function size_type (line 185) | size_type count(const key_type& __x) const {
function iterator (line 188) | iterator lower_bound(const key_type& __x) const {
function iterator (line 191) | iterator upper_bound(const key_type& __x) const {
FILE: stl-3.3-source/stl_slist.h
type _Slist_node_base (line 31) | struct _Slist_node_base
function _Slist_node_base (line 36) | inline _Slist_node_base*
function _Slist_node_base (line 45) | inline _Slist_node_base*
function _Slist_node_base (line 54) | inline const _Slist_node_base*
function __slist_splice_after (line 63) | inline void __slist_splice_after(_Slist_node_base* __pos,
function __slist_splice_after (line 76) | inline void
function _Slist_node_base (line 88) | inline _Slist_node_base* __slist_reverse(_Slist_node_base* __node)
function __slist_size (line 102) | inline size_t __slist_size(_Slist_node_base* __node)
type _Slist_iterator_base (line 116) | struct _Slist_iterator_base
type _Slist_iterator (line 138) | typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
type _Slist_iterator (line 139) | typedef _Slist_iterator<_Tp, const
type _Slist_iterator (line 140) | typedef _Slist_iterator<_Tp, _Ref, _Ptr> _Self;
type _Tp (line 142) | typedef _Tp value_type;
type _Ptr (line 143) | typedef _Ptr pointer;
type _Ref (line 144) | typedef _Ref reference;
type _Slist_node (line 145) | typedef _Slist_node<_Tp> _Node;
function _Slist_iterator_base (line 147) | _Slist_iterator_base(__x) {}
function _Slist_iterator_base (line 149) | _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}
function reference (line 151) | reference operator*() const { return ((_Node*) _M_node)->_M_data; }
function pointer (line 153) | pointer operator->() const { return &(operator*()); }
function forward_iterator_tag (line 175) | inline forward_iterator_tag iterator_category(const _Slist_iterator_base...
function _Tp (line 180) | _Tp* value_type(const _Slist_iterator<_Tp, _Ref, _Ptr>&) {
function _M_node_allocator (line 203) | _Slist_alloc_base(const allocator_type& __a) : _M_node_allocator(__a) {}
function _M_put_node (line 208) | void _M_put_node(_Slist_node<_Tp>* __p)
type typename (line 221) | typedef typename _Alloc_traits<_Tp,_Allocator>::allocator_type
function _M_put_node (line 231) | void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1...
type typename (line 246) | typedef typename _Base::allocator_type allocator_type;
function _Base (line 248) | _Slist_base(const allocator_type& __a)
type _Alloc (line 270) | typedef _Alloc allocator_type;
function _M_put_node (line 279) | void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1...
function _Slist_node_base (line 281) | _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
type value_type (line 324) | typedef value_type* pointer;
type value_type (line 325) | typedef const value_type* const_pointer;
type value_type (line 326) | typedef value_type& reference;
type value_type (line 327) | typedef const value_type& const_reference;
type size_type (line 328) | typedef size_t size_type;
type difference_type (line 329) | typedef ptrdiff_t difference_type;
type _Slist_iterator (line 331) | typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
type _Slist_iterator (line 332) | typedef _Slist_iterator<_Tp, const
type typename (line 334) | typedef typename _Base::allocator_type allocator_type;
function allocator_type (line 335) | allocator_type get_allocator() const { return _Base::get_allocator(); }
function _Node (line 352) | _Node* _M_create_node() {
function explicit (line 369) | explicit slist(size_type __n) : _Base(allocator_type())
function _Base (line 377) | _Base(__a)
function _Base (line 389) | slist(const slist& __x) : _Base(__x.get_allocator())
type typename (line 412) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function iterator (line 432) | iterator end() { return iterator(0); }
function iterator (line 442) | iterator before_begin() { return iterator((_Node*) &this->_M_head); }
function swap (line 452) | void swap(slist& __x)
function push_front (line 460) | void push_front(const value_type& __x) {
function push_front (line 463) | void push_front() { __slist_make_link(&this->_M_head, _M_create_node()); }
function pop_front (line 464) | void pop_front() {
function iterator (line 471) | iterator previous(const_iterator __pos) {
function const_iterator (line 474) | const_iterator previous(const_iterator __pos) const {
function _Node (line 484) | _Node* _M_insert_after(_Node_base* __pos) {
function _M_insert_after_fill (line 488) | void _M_insert_after_fill(_Node_base* __pos,
type typename (line 500) | typedef typename _Is_integer<_InIter>::_Integral _Integral;
function _M_insert_after_range (line 522) | void _M_insert_after_range(_Node_base* __pos,
function _M_insert_after_range (line 529) | void _M_insert_after_range(_Node_base* __pos,
function iterator (line 546) | iterator insert_after(iterator __pos) {
function insert_after (line 550) | void insert_after(iterator __pos, size_type __n, const value_type& __x) {
function insert_after (line 565) | void insert_after(iterator __pos,
function insert_after (line 569) | void insert_after(iterator __pos,
function iterator (line 576) | iterator insert(iterator __pos, const value_type& __x) {
function iterator (line 582) | iterator insert(iterator __pos) {
function insert (line 588) | void insert(iterator __pos, size_type __n, const value_type& __x) {
function insert (line 605) | void insert(iterator __pos, const_iterator __first, const_iterator __las...
function insert (line 609) | void insert(iterator __pos, const value_type* __first,
function iterator (line 622) | iterator erase_after(iterator __before_first, iterator __last) {
function iterator (line 627) | iterator erase(iterator __pos) {
function iterator (line 631) | iterator erase(iterator __first, iterator __last) {
function resize (line 637) | void resize(size_type new_size) { resize(new_size, _Tp()); }
function clear (line 638) | void clear() { this->_M_erase_after(&this->_M_head, 0); }
function splice_after (line 653) | void splice_after(iterator __pos, iterator __prev)
function splice_after (line 663) | void splice_after(iterator __pos, slist& __x)
function splice (line 669) | void splice(iterator __pos, slist& __x) {
function splice (line 676) | void splice(iterator __pos, slist& __x, iterator __i) {
function splice (line 684) | void splice(iterator __pos, slist& __x, iterator __first, iterator __last)
type typename (line 782) | typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
type output_iterator_tag (line 1011) | typedef output_iterator_tag iterator_category;
type value_type (line 1012) | typedef void value_type;
type difference_type (line 1013) | typedef void difference_type;
type pointer (line 1014) | typedef void pointer;
type reference (line 1015) | typedef void reference;
FILE: stl-3.3-source/stl_stack.h
type typename (line 58) | typedef typename _Sequence::value_type _Sequence_value_type;
type typename (line 78) | typedef typename _Sequence::size_type size_type;
type _Sequence (line 79) | typedef _Sequence container_type;
type typename (line 81) | typedef typename _Sequence::reference reference;
type typename (line 82) | typedef typename _Sequence::const_reference const_reference;
function explicit (line 87) | explicit stack(const _Sequence& __s) : c(__s) {}
function reference (line 91) | reference top() { return c.back(); }
function push (line 93) | void push(const value_type& __x) { c.push_back(__x); }
function pop (line 94) | void pop() { c.pop_back(); }
FILE: stl-3.3-source/stl_string_fwd.h
type basic_string (line 29) | typedef basic_string<char> string;
type basic_string (line 30) | typedef basic_string<wchar_t> wstring;
FILE: stl-3.3-source/stl_tempbuf.h
function _M_allocate_buffer (line 85) | void _M_allocate_buffer() {
function _M_initialize_buffer (line 100) | void _M_initialize_buffer(const _Tp&, __true_type) {}
function _M_initialize_buffer (line 101) | void _M_initialize_buffer(const _Tp& val, __false_type) {
function _Tp (line 108) | _Tp* begin() { return _M_buffer; }
function _Tp (line 109) | _Tp* end() { return _M_buffer + _M_len; }
type typename (line 114) | typedef typename __type_traits<_Tp>::is_POD_type _Trivial;
type typename (line 116) | typedef typename __type_traits<_Tp>::has_trivial_default_constructor
FILE: stl-3.3-source/stl_threads.h
type _Refcount_Base (line 54) | struct _Refcount_Base
function _Atomic_swap (line 121) | inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
function _Atomic_swap (line 129) | inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
function _Atomic_swap (line 146) | inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
function _Atomic_swap (line 167) | inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
function _Atomic_swap (line 194) | inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
function _Atomic_swap (line 202) | static inline unsigned long _Atomic_swap(unsigned long * __p, unsigned l...
function if (line 238) | struct _STL_mutex_lock
function _M_release_lock (line 299) | void _M_release_lock() {
function _M_initialize (line 320) | void _M_initialize() { pthread_mutex_init(&_M_lock, NULL); }
function _M_acquire_lock (line 321) | void _M_acquire_lock() { pthread_mutex_lock(&_M_lock); }
function _M_release_lock (line 322) | void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
function _M_initialize (line 325) | void _M_initialize() { mutex_init(&_M_lock, USYNC_THREAD, 0); }
function _M_acquire_lock (line 326) | void _M_acquire_lock() { mutex_lock(&_M_lock); }
function _M_release_lock (line 327) | void _M_release_lock() { mutex_unlock(&_M_lock); }
function _M_initialize (line 329) | void _M_initialize() {}
function _M_acquire_lock (line 330) | void _M_acquire_lock() {}
function _M_release_lock (line 331) | void _M_release_lock() {}
function _STL_auto_lock (line 355) | struct _STL_auto_lock
FILE: stl-3.3-source/stl_tree.h
type _Rb_tree_Color_type (line 67) | typedef bool _Rb_tree_Color_type;
function _S_maximum (line 71) | struct _Rb_tree_node_base
function else (line 102) | struct _Rb_tree_base_iterator
function _M_decrement (line 127) | void _M_decrement()
type _Value (line 152) | typedef _Value value_type;
type _Ref (line 153) | typedef _Ref reference;
type _Ptr (line 154) | typedef _Ptr pointer;
type _Rb_tree_iterator (line 155) | typedef _Rb_tree_iterator<_Value, _Value&, _Value*>
type _Rb_tree_iterator (line 157) | typedef _Rb_tree_iterator<_Value, const
type _Rb_tree_iterator (line 159) | typedef _Rb_tree_iterator<_Value, _Ref, _Ptr>
type _Rb_tree_node (line 161) | typedef _Rb_tree_node<_Value>* _Link_type;
function reference (line 167) | reference operator*() const { return _Link_type(_M_node)->_M_value_field; }
function pointer (line 169) | pointer operator->() const { return &(operator*()); }
function bidirectional_iterator_tag (line 199) | inline bidirectional_iterator_tag
function _Rb_tree_base_iterator (line 204) | inline _Rb_tree_base_iterator::difference_type*
function _Value (line 210) | _Value* value_type(const _Rb_tree_iterator<_Value, _Ref, _Ptr>&) {
function _Rb_tree_rotate_left (line 216) | inline void
function _Rb_tree_rotate_right (line 235) | inline void
function _Rb_tree_rebalance (line 254) | inline void
function _Rb_tree_node_base (line 299) | inline _Rb_tree_node_base*
function _M_put_node (line 455) | void _M_put_node(_Rb_tree_node<_Tp>* __p)
type typename (line 463) | typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
function _M_header (line 466) | _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {}
type typename (line 471) | typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type
function _M_put_node (line 476) | void _M_put_node(_Rb_tree_node<_Tp>* __p)
type typename (line 488) | typedef typename _Base::allocator_type allocator_type;
function _Base (line 490) | _Rb_tree_base(const allocator_type& __a)
type _Alloc (line 501) | typedef _Alloc allocator_type;
function _M_header (line 504) | _Rb_tree_base(const allocator_type&)
type simple_alloc (line 511) | typedef simple_alloc<_Rb_tree_node<_Tp>, _Alloc> _Alloc_type;
function _M_put_node (line 515) | void _M_put_node(_Rb_tree_node<_Tp>* __p)
type _Rb_tree_node (line 527) | typedef _Rb_tree_node<_Value> _Rb_tree_node;
type _Rb_tree_Color_type (line 528) | typedef _Rb_tree_Color_type _Color_type;
type _Value (line 531) | typedef _Value value_type;
type value_type (line 532) | typedef value_type* pointer;
type value_type (line 533) | typedef const value_type* const_pointer;
type value_type (line 534) | typedef value_type& reference;
type value_type (line 535) | typedef const value_type& const_reference;
type _Rb_tree_node (line 536) | typedef _Rb_tree_node* _Link_type;
type size_type (line 537) | typedef size_t size_type;
type difference_type (line 538) | typedef ptrdiff_t difference_type;
type typename (line 540) | typedef typename _Base::allocator_type allocator_type;
function allocator_type (line 541) | allocator_type get_allocator() const { return _Base::get_allocator(); }
function _Link_type (line 562) | _Link_type _M_clone_node(_Link_type __x)
function destroy_node (line 571) | void destroy_node(_Link_type __p)
function _Link_type (line 588) | static _Link_type& _S_left(_Link_type __x)
function _Link_type (line 590) | static _Link_type& _S_right(_Link_type __x)
function _Link_type (line 592) | static _Link_type& _S_parent(_Link_type __x)
function reference (line 594) | static reference _S_value(_Link_type __x)
function _Key (line 596) | static const _Key& _S_key(_Link_type __x)
function _Color_type (line 598) | static _Color_type& _S_color(_Link_type __x)
function _Link_type (line 601) | static _Link_type& _S_left(_Base_ptr __x)
function _Link_type (line 603) | static _Link_type& _S_right(_Base_ptr __x)
function _Link_type (line 605) | static _Link_type& _S_parent(_Base_ptr __x)
function reference (line 607) | static reference _S_value(_Base_ptr __x)
function _Key (line 609) | static const _Key& _S_key(_Base_ptr __x)
function _Color_type (line 611) | static _Color_type& _S_color(_Base_ptr __x)
function _Link_type (line 614) | static _Link_type _S_minimum(_Link_type __x)
function _Link_type (line 617) | static _Link_type _S_maximum(_Link_type __x)
type _Rb_tree_iterator (line 622) | typedef _Rb_tree_iterator<value_type, const_reference, const_pointer>
type reverse_iterator (line 626) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 627) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_bidirectional_iterator (line 629) | typedef reverse_bidirectional_iterator<iterator, value_type, reference,
type reverse_bidirectional_iterator (line 632) | typedef reverse_bidirectional_iterator<const_iterator, value_type,
function iterator (line 686) | iterator begin() { return _M_leftmost(); }
function iterator (line 688) | iterator end() { return _M_header; }
function reverse_iterator (line 690) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 694) | reverse_iterator rend() { return reverse_iterator(begin()); }
function swap (line 702) | void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) {
function clear (line 732) | void clear() {
function else (line 1133) | else
function __black_count (line 1289) | inline int
type typename (line 1347) | typedef typename _Base::allocator_type allocator_type;
FILE: stl-3.3-source/stl_uninitialized.h
function _ForwardIter (line 66) | _ForwardIter
function _ForwardIter (line 75) | _ForwardIter
function wchar_t (line 89) | inline wchar_t*
function __uninitialized_fill_aux (line 144) | void
function __uninitialized_fill (line 165) | void __uninitialized_fill(_ForwardIter __first,
function uninitialized_fill (line 174) | void uninitialized_fill(_ForwardIter __first,
function _ForwardIter (line 184) | _ForwardIter
function _ForwardIter (line 206) | _ForwardIter
function _ForwardIter (line 214) | _ForwardIter
function _ForwardIter (line 229) | _ForwardIter
function _ForwardIter (line 245) | _ForwardIter
function __uninitialized_copy_fill (line 261) | void
FILE: stl-3.3-source/stl_vector.h
function _Tp (line 69) | _Tp* _M_allocate(size_t __n)
function _M_deallocate (line 71) | void _M_deallocate(_Tp* __p, size_t __n)
type typename (line 80) | typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
type typename (line 93) | typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;
function _Tp (line 94) | _Tp* _M_allocate(size_t __n)
function _M_deallocate (line 96) | void _M_deallocate(_Tp* __p, size_t __n)
type typename (line 108) | typedef typename _Base::allocator_type allocator_type;
function _Base (line 110) | _Vector_base(const allocator_type& __a) : _Base(__a) {}
type simple_alloc (line 145) | typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;
function _Tp (line 146) | _Tp* _M_allocate(size_t __n)
function _M_deallocate (line 148) | void _M_deallocate(_Tp* __p, size_t __n)
type value_type (line 165) | typedef value_type* pointer;
type value_type (line 166) | typedef const value_type* const_pointer;
type value_type (line 167) | typedef value_type* iterator;
type value_type (line 168) | typedef const value_type* const_iterator;
type value_type (line 169) | typedef value_type& reference;
type value_type (line 170) | typedef const value_type& const_reference;
type size_type (line 171) | typedef size_t size_type;
type difference_type (line 172) | typedef ptrdiff_t difference_type;
type typename (line 174) | typedef typename _Base::allocator_type allocator_type;
type reverse_iterator (line 178) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 179) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 181) | typedef reverse_iterator<const_iterator, value_type, const_reference,
type reverse_iterator (line 183) | typedef reverse_iterator<iterator, value_type, reference, difference_type>
function iterator (line 203) | iterator end() { return _M_finish; }
function reverse_iterator (line 206) | reverse_iterator rbegin()
function const_reverse_iterator (line 208) | const_reverse_iterator rbegin() const
function reference (line 224) | reference operator[](size_type __n) { return *(begin() + __n); }
function const_reference (line 225) | const_reference operator[](size_type __n) const { return *(begin() + __n...
function _M_range_check (line 228) | void _M_range_check(size_type __n) const {
function reference (line 233) | reference at(size_type __n)
function const_reference (line 235) | const_reference at(size_type __n) const
function _Base (line 240) | _Base(__a) {}
function explicit (line 247) | explicit vector(size_type __n)
function _Base (line 259) | _Base(__a) {
function reserve (line 287) | void reserve(size_type __n) {
function assign (line 304) | void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val...
type typename (line 311) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function reference (line 333) | reference front() { return *begin(); }
function reference (line 335) | reference back() { return *(end() - 1); }
function push_back (line 338) | void push_back(const _Tp& __x) {
function push_back (line 346) | void push_back() {
function swap (line 354) | void swap(vector<_Tp, _Alloc>& __x) {
function iterator (line 360) | iterator insert(iterator __position, const _Tp& __x) {
function iterator (line 370) | iterator insert(iterator __position) {
type typename (line 384) | typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
function insert (line 404) | void insert (iterator __pos, size_type __n, const _Tp& __x)
function pop_back (line 409) | void pop_back() {
function iterator (line 413) | iterator erase(iterator __position) {
function iterator (line 420) | iterator erase(iterator __first, iterator __last) {
function resize (line 427) | void resize(size_type __new_size, const _Tp& __x) {
function resize (line 433) | void resize(size_type __new_size) { resize(__new_size, _Tp()); }
function clear (line 434) | void clear() { erase(begin(), end()); }
function iterator (line 451) | iterator _M_allocate_and_copy(size_type __n, const_iterator __first,
FILE: stl-3.3-source/type_traits.h
type __true_type (line 55) | struct __true_type {
type __false_type (line 58) | struct __false_type {
type __true_type (line 63) | typedef __true_type this_dummy_member_must_be_first;
type __false_type (line 81) | typedef __false_type has_trivial_default_constructor;
type __false_type (line 82) | typedef __false_type has_trivial_copy_constructor;
type __false_type (line 83) | typedef __false_type has_trivial_assignment_operator;
type __false_type (line 84) | typedef __false_type has_trivial_destructor;
type __false_type (line 85) | typedef __false_type is_POD_type;
type __true_type (line 97) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 98) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 99) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 100) | typedef __true_type has_trivial_destructor;
type __true_type (line 101) | typedef __true_type is_POD_type;
type __true_type (line 107) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 108) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 109) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 110) | typedef __true_type has_trivial_destructor;
type __true_type (line 111) | typedef __true_type is_POD_type;
type __true_type (line 115) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 116) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 117) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 118) | typedef __true_type has_trivial_destructor;
type __true_type (line 119) | typedef __true_type is_POD_type;
type __true_type (line 123) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 124) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 125) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 126) | typedef __true_type has_trivial_destructor;
type __true_type (line 127) | typedef __true_type is_POD_type;
type __true_type (line 133) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 134) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 135) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 136) | typedef __true_type has_trivial_destructor;
type __true_type (line 137) | typedef __true_type is_POD_type;
type __true_type (line 143) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 144) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 145) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 146) | typedef __true_type has_trivial_destructor;
type __true_type (line 147) | typedef __true_type is_POD_type;
type __true_type (line 151) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 152) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 153) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 154) | typedef __true_type has_trivial_destructor;
type __true_type (line 155) | typedef __true_type is_POD_type;
type __true_type (line 159) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 160) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 161) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 162) | typedef __true_type has_trivial_destructor;
type __true_type (line 163) | typedef __true_type is_POD_type;
type __true_type (line 167) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 168) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 169) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 170) | typedef __true_type has_trivial_destructor;
type __true_type (line 171) | typedef __true_type is_POD_type;
type __true_type (line 175) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 176) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 177) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 178) | typedef __true_type has_trivial_destructor;
type __true_type (line 179) | typedef __true_type is_POD_type;
type __true_type (line 183) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 184) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 185) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 186) | typedef __true_type has_trivial_destructor;
type __true_type (line 187) | typedef __true_type is_POD_type;
type __true_type (line 193) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 194) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 195) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 196) | typedef __true_type has_trivial_destructor;
type __true_type (line 197) | typedef __true_type is_POD_type;
type __true_type (line 201) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 202) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 203) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 204) | typedef __true_type has_trivial_destructor;
type __true_type (line 205) | typedef __true_type is_POD_type;
type __true_type (line 211) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 212) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 213) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 214) | typedef __true_type has_trivial_destructor;
type __true_type (line 215) | typedef __true_type is_POD_type;
type __true_type (line 219) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 220) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 221) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 222) | typedef __true_type has_trivial_destructor;
type __true_type (line 223) | typedef __true_type is_POD_type;
type __true_type (line 227) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 228) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 229) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 230) | typedef __true_type has_trivial_destructor;
type __true_type (line 231) | typedef __true_type is_POD_type;
type __true_type (line 238) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 239) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 240) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 241) | typedef __true_type has_trivial_destructor;
type __true_type (line 242) | typedef __true_type is_POD_type;
type __true_type (line 248) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 249) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 250) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 251) | typedef __true_type has_trivial_destructor;
type __true_type (line 252) | typedef __true_type is_POD_type;
type __true_type (line 256) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 257) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 258) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 259) | typedef __true_type has_trivial_destructor;
type __true_type (line 260) | typedef __true_type is_POD_type;
type __true_type (line 264) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 265) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 266) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 267) | typedef __true_type has_trivial_destructor;
type __true_type (line 268) | typedef __true_type is_POD_type;
type __true_type (line 272) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 273) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 274) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 275) | typedef __true_type has_trivial_destructor;
type __true_type (line 276) | typedef __true_type is_POD_type;
type __true_type (line 280) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 281) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 282) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 283) | typedef __true_type has_trivial_destructor;
type __true_type (line 284) | typedef __true_type is_POD_type;
type __true_type (line 288) | typedef __true_type has_trivial_default_constructor;
type __true_type (line 289) | typedef __true_type has_trivial_copy_constructor;
type __true_type (line 290) | typedef __true_type has_trivial_assignment_operator;
type __true_type (line 291) | typedef __true_type has_trivial_destructor;
type __true_type (line 292) | typedef __true_type is_POD_type;
type __false_type (line 302) | typedef __false_type _Integral;
type __true_type (line 308) | typedef __true_type _Integral;
type __true_type (line 314) | typedef __true_type _Integral;
type __true_type (line 318) | typedef __true_type _Integral;
type __true_type (line 322) | typedef __true_type _Integral;
type __true_type (line 328) | typedef __true_type _Integral;
type __true_type (line 334) | typedef __true_type _Integral;
type __true_type (line 338) | typedef __true_type _Integral;
type __true_type (line 342) | typedef __true_type _Integral;
type __true_type (line 346) | typedef __true_type _Integral;
type __true_type (line 350) | typedef __true_type _Integral;
type __true_type (line 354) | typedef __true_type _Integral;
type __true_type (line 360) | typedef __true_type _Integral;
type __true_type (line 364) | typedef __true_type _Integral;
FILE: stl-gatieme/1-stl_config/1config-inclass-init.cpp
class testClass (line 6) | class testClass
function main (line 16) | int main()
FILE: stl-gatieme/1-stl_config/1config-operator-overloading.cpp
class INT (line 5) | class INT
method INT (line 10) | INT(int i) : m_i(i) { }
method INT (line 14) | INT& operator++()
method INT (line 22) | const INT operator++(int)
method INT (line 31) | INT& operator--()
method INT (line 38) | const INT operator--(int)
function ostream (line 54) | ostream& operator<<(ostream& os, const INT& i)
function main (line 60) | int main()
FILE: stl-gatieme/1-stl_config/1config-template-exp-special.cpp
type hash (line 6) | struct hash
type hash<char> (line 15) | struct hash<char>
type hash<unsigned char> (line 24) | struct hash<unsigned char>
function main (line 32) | int main()
FILE: stl-gatieme/1-stl_config/1config-temporary-object.cpp
class print (line 8) | class print
function main (line 17) | int main()
FILE: stl-gatieme/1-stl_config/1config.cpp
function test (line 6) | void test(void)
function main (line 207) | int main(void)
FILE: stl-gatieme/1-stl_config/1config10.cpp
class alloc (line 7) | class alloc
class deque (line 12) | class deque
method deque (line 15) | deque()
class stack (line 22) | class stack
method stack (line 25) | stack()
function main (line 34) | int main()
FILE: stl-gatieme/1-stl_config/1config11.cpp
class alloc (line 6) | class alloc
function __deque_buf_size (line 10) | inline size_t __deque_buf_size(size_t n, size_t sz)
type __deque_iterator (line 16) | struct __deque_iterator
method buffer_size (line 20) | static size_t buffer_size()
class deque (line 27) | class deque
function main (line 33) | int main()
FILE: stl-gatieme/1-stl_config/1config2.cpp
function main (line 7) | int main()
FILE: stl-gatieme/1-stl_config/1config3.cpp
class testclass (line 6) | class testclass
function main (line 15) | int main()
FILE: stl-gatieme/1-stl_config/1config5.cpp
type testClass (line 6) | struct testClass
method testClass (line 8) | testClass()
type testClass<T*, T*> (line 15) | struct testClass<T*, T*>
method testClass (line 17) | testClass()
type testClass<const T*, T*> (line 24) | struct testClass<const T*, T*>
method testClass (line 26) | testClass()
function main (line 32) | int main()
FILE: stl-gatieme/1-stl_config/1config8.cpp
class alloc (line 5) | class alloc
class vector (line 10) | class vector
method insert (line 17) | void insert(iterator position, I first, I last)
function main (line 23) | int main()
FILE: stl-gatieme/1-stl_config/1functor.cpp
type myplus (line 8) | struct myplus
method T (line 10) | T operator()(const T& x, const T& y) const
type myminus (line 19) | struct myminus
method T (line 21) | T operator()(const T& x, const T& y) const
function main (line 27) | int main()
FILE: stl-gatieme/1-stl_config/1qsort.cpp
function main (line 11) | int main( )
function fcmp (line 32) | int fcmp(const void *elem1, const void *elem2)
FILE: stl-gatieme/2-defalloc/2jjalloc.h
function namespace (line 13) | namespace JJ
FILE: stl-gatieme/2-defalloc/defalloc.h
function T (line 50) | T* allocate(ptrdiff_t size, T*) {
function deallocate (line 62) | void deallocate(T* buffer) {
type T (line 70) | typedef T* pointer;
type T (line 71) | typedef const T* const_pointer;
type T (line 72) | typedef T& reference;
type T (line 73) | typedef const T& const_reference;
type size_type (line 74) | typedef size_t size_type;
type difference_type (line 75) | typedef ptrdiff_t difference_type;
function pointer (line 76) | pointer allocate(size_type n) {
function deallocate (line 79) | void deallocate(pointer p) { ::deallocate(p); }
function pointer (line 80) | pointer address(reference x) { return (pointer)&x; }
function const_pointer (line 81) | const_pointer const_address(const_reference x) {
function size_type (line 84) | size_type init_page_size() {
function class (line 92) | class allocator<void> {
FILE: stl-gatieme/2-defalloc/simple_jjallocator.h
function namespace (line 9) | namespace JJ
FILE: stl-gatieme/2-defalloc/stl_alloc.h
function deallocate (line 172) | static void deallocate(void *p, size_t /* n */)
type __malloc_alloc_template (line 233) | typedef __malloc_alloc_template<0> malloc_alloc;
function T (line 252) | static T *allocate(void)
function deallocate (line 254) | static void deallocate(T *p, size_t n)
function deallocate (line 256) | static void deallocate(T *p)
function deallocate (line 286) | static void deallocate(void *p, size_t n)
type malloc_alloc (line 306) | typedef malloc_alloc alloc;
type malloc_alloc (line 307) | typedef malloc_alloc single_client_alloc;
function ROUND_UP (line 369) | static size_t ROUND_UP(size_t bytes)
function FREELIST_INDEX (line 395) | static size_t FREELIST_INDEX(size_t bytes)
function class (line 439) | class lock
function deallocate (line 478) | static void deallocate(void *p, size_t n)
type __default_alloc_template (line 502) | typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
type timespec (line 682) | struct timespec
FILE: stl-gatieme/2-defalloc/test.cpp
function main (line 9) | int main()
FILE: stl-gatieme/3-iterator/3autoptr.cpp
type AutoPtrRef (line 12) | struct AutoPtrRef
method AutoPtrRef (line 16) | AutoPtrRef(U* p)
class AutoPtr (line 27) | class AutoPtr
method AutoPtr (line 31) | explicit AutoPtr(T *p = NULL)
method AutoPtr (line 39) | AutoPtr(AutoPtr<U> &rhs) // Ҫͷrhsָָ ˲Ϊconst
method T (line 56) | T* get( ) const
method T (line 62) | T* release( )
method reset (line 72) | void reset(T *p)
method T (line 86) | T& operator*( ) const
method T (line 107) | T* operator->( ) const
method AutoPtr (line 113) | AutoPtr& operator=(AutoPtr<U> &ptr)
method AutoPtr (line 134) | AutoPtr(AutoPtrRef<T> ref)
method AutoPtr (line 141) | AutoPtr& operator=(AutoPtrRef<T> ref)
function main (line 169) | int main(void)
FILE: stl-gatieme/3-iterator/3find.cpp
function main (line 10) | int main()
FILE: stl-gatieme/3-iterator/3function_template1.cpp
function func_impl (line 7) | void func_impl(Iter iter, T t)
function func (line 19) | inline func(Iter iter)
function main (line 25) | int main( )
FILE: stl-gatieme/3-iterator/3function_template2.cpp
type MyIter (line 8) | struct MyIter
method MyIter (line 10) | MyIter(T *p = NULL)
method T (line 16) | T& operator*( ) const
function func (line 29) | typename Iter::value_type /// һfuncķֵ
function main (line 37) | int main(void)
FILE: stl-gatieme/3-iterator/3function_template3.cpp
type MyIter (line 12) | struct MyIter
method MyIter (line 14) | MyIter(T *p = NULL)
method T (line 20) | T& operator*( ) const
type iterator_traits (line 51) | struct iterator_traits
type iterator_traits<T *> (line 58) | struct iterator_traits<T *>
type iterator_traits<const T *> (line 65) | struct iterator_traits<const T *>
function func (line 73) | typename iterator_traits<Iter>::value_type
function main (line 82) | int main(void)
FILE: stl-gatieme/3-iterator/3mylist.h
function ListItem (line 20) | ListItem *next( ) const
function insert_end (line 40) | void insert_end(T value)
FILE: stl-gatieme/3-iterator/3mylist_iter_test.cpp
function main (line 15) | int main( )
FILE: stl-gatieme/3-iterator/3tag_test.cpp
type B (line 4) | struct B /// B ɱΪInputIterator
type D1 (line 9) | struct D1 : public B /// D1 ɱΪForwardIteraor
type D2 (line 14) | struct D2 : public D1 // D2 ɱΪBidirectionalIterator
function func (line 21) | func(I &p, B)
function func (line 27) | func(I &p, D2)
function main (line 35) | int main(void)
FILE: stl-gatieme/3-iterator/3templatespecial_class.cpp
class Compare (line 6) | class Compare
method IsEqual (line 9) | static bool IsEqual(const T& lh, const T& rh)
class Compare<float> (line 20) | class Compare<float>
method IsEqual (line 23) | static bool IsEqual(const float& lh, const float& rh)
class Compare<double> (line 33) | class Compare<double>
method IsEqual (line 36) | static bool IsEqual(const double& lh, const double& rh)
function main (line 48) | int main(void)
FILE: stl-gatieme/3-iterator/3templatespecial_func.cpp
function compare (line 7) | int compare(const T left, const T right)
function compare (line 34) | int compare(char* left, char* right)
function main (line 41) | int main( )
FILE: stl-gatieme/3-iterator/3test_typeid.cpp
class A (line 13) | class A
function main (line 17) | int main( )
FILE: stl-gatieme/3-iterator/test_auto_ptr.cpp
class A (line 5) | class A
method A (line 8) | A( )
function sink (line 27) | void sink(auto_ptr<A> a)
function create (line 33) | auto_ptr<A> create()
function main (line 40) | int main(int argc, char *argv[])
FILE: stl-gatieme/3-iterator/test_bad_typeid.cpp
class A (line 8) | class A
function main (line 15) | int main()
FILE: stl-gatieme/3-iterator/typeinfo.h
function namespace (line 41) | namespace __cxxabiv1
function namespace (line 78) | namespace std
FILE: stl-gatieme/4-sequence-containers/4deque_test.cpp
function Print (line 9) | void Print(int a)
function main (line 15) | int main( )
FILE: stl-gatieme/4-sequence-containers/4heap_test.cpp
function Print (line 8) | void Print(int a)
function main (line 14) | int main( )
FILE: stl-gatieme/4-sequence-containers/4queue_test.cpp
function main (line 13) | int main( )
FILE: stl-gatieme/4-sequence-containers/4stack_test.cpp
function main (line 13) | int main( )
FILE: stl-gatieme/4-sequence-containers/4vector_reset.cpp
function main (line 10) | int main( )
FILE: stl-gatieme/4-sequence-containers/4vector_test.cpp
function Print (line 8) | void Print(int a)
function main (line 14) | int main( )
FILE: stl侯杰源码/algo/accu1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/adjdiff1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/adjfind1.cpp
function doubled (line 15) | bool doubled (int elem1, int elem2)
function main (line 20) | int main()
FILE: stl侯杰源码/algo/algostuff.hpp
function PRINT_ELEMENTS (line 32) | inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
function INSERT_ELEMENTS (line 48) | inline void INSERT_ELEMENTS (T& coll, int first, int last)
FILE: stl侯杰源码/algo/bounds1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/bsearch1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/copy1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/copy2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/copy3.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/algo/count1.cpp
function isEven (line 14) | bool isEven (int elem)
function main (line 19) | int main()
FILE: stl侯杰源码/algo/eqrange1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/equal1.cpp
function bothEvenOrOdd (line 14) | bool bothEvenOrOdd (int elem1, int elem2)
function main (line 19) | int main()
FILE: stl侯杰源码/algo/fill1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/find1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/find2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/findend1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/findof1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/foreach1.cpp
function print (line 15) | void print (int elem)
function main (line 20) | int main()
FILE: stl侯杰源码/algo/foreach2.cpp
class AddValue (line 16) | class AddValue {
method AddValue (line 21) | AddValue (const T& v) : theValue(v) {
function main (line 30) | int main()
FILE: stl侯杰源码/algo/foreach3.cpp
class MeanValue (line 15) | class MeanValue {
method MeanValue (line 21) | MeanValue () : num(0), sum(0) {
function main (line 37) | int main()
FILE: stl侯杰源码/algo/generate.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/algo/heap1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/imerge1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/includes.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/inner1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/lexico1.cpp
function printCollection (line 14) | void printCollection (const list<int>& l)
function lessForCollection (line 19) | bool lessForCollection (const list<int>& l1, const list<int>& l2)
function main (line 26) | int main()
FILE: stl侯杰源码/algo/merge1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/minmax1.cpp
function absLess (line 15) | bool absLess (int elem1, int elem2)
function main (line 20) | int main()
FILE: stl侯杰源码/algo/misma1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/nth1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/part1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/partsum1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/perm1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/psort1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/psort2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/random1.cpp
class MyRandom (line 15) | class MyRandom {
function main (line 25) | int main()
FILE: stl侯杰源码/algo/relabs.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/remove1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/remove2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/replace1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/replace2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/reverse1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/rotate1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/rotate2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/search1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/search2.cpp
function checkEven (line 15) | bool checkEven (int elem, bool even)
function main (line 25) | int main()
FILE: stl侯杰源码/algo/searchn1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/setalgos.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/sort1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/sort2.cpp
function lessLength (line 14) | bool lessLength (const string& s1, const string& s2)
function main (line 19) | int main()
FILE: stl侯杰源码/algo/swap1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/transf1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/transf2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/unique1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/algo/unique2.cpp
function differenceOne (line 14) | bool differenceOne (int elem1, int elem2)
function main (line 19) | int main()
FILE: stl侯杰源码/algo/unique3.cpp
function bothSpaces (line 16) | bool bothSpaces (char elem1, char elem2)
function main (line 21) | int main()
FILE: stl侯杰源码/cont/Queue.hpp
class Queue (line 22) | class Queue {
class ReadEmptyQueue (line 29) | class ReadEmptyQueue : public std::exception {
method size (line 37) | typename std::deque<T>::size_type size() const {
method empty (line 42) | bool empty() const {
method push (line 47) | void push (const T& elem) {
method T (line 52) | T pop () {
method T (line 62) | T& front () {
FILE: stl侯杰源码/cont/Stack.hpp
class Stack (line 22) | class Stack {
class ReadEmptyStack (line 29) | class ReadEmptyStack : public std::exception {
method size (line 37) | typename std::deque<T>::size_type size() const {
method empty (line 42) | bool empty() const {
method push (line 47) | void push (const T& elem) {
method T (line 52) | T pop () {
method T (line 62) | T& top () {
FILE: stl侯杰源码/cont/array1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/bitset1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/cont/bitset2.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/carray.hpp
class carray (line 14) | class carray {
method iterator (line 29) | iterator begin() { return v; }
method const_iterator (line 30) | const_iterator begin() const { return v; }
method iterator (line 31) | iterator end() { return v+thesize; }
method const_iterator (line 32) | const_iterator end() const { return v+thesize; }
method reference (line 35) | reference operator[](std::size_t i) { return v[i]; }
method const_reference (line 36) | const_reference operator[](std::size_t i) const { return v[i]; }
method size_type (line 39) | size_type size() const { return thesize; }
method size_type (line 40) | size_type max_size() const { return thesize; }
method T (line 43) | T* as_array() { return v; }
FILE: stl侯杰源码/cont/carray1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/countptr.hpp
class CountedPtr (line 19) | class CountedPtr {
method CountedPtr (line 27) | explicit CountedPtr (T* p=0)
method CountedPtr (line 32) | CountedPtr (const CountedPtr<T>& p) throw()
method T (line 54) | T& operator*() const throw() {
method T (line 57) | T* operator->() const throw() {
method dispose (line 62) | void dispose() {
FILE: stl侯杰源码/cont/deque1.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/cont/list1.cpp
function printLists (line 17) | void printLists (const list<int>& l1, const list<int>& l2)
function main (line 26) | int main()
FILE: stl侯杰源码/cont/map1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/cont/mapcmp.cpp
class RuntimeStringCmp (line 22) | class RuntimeStringCmp {
type cmp_mode (line 25) | enum cmp_mode {normal, nocase}
method nocase_compare (line 31) | static bool nocase_compare (char c1, char c2)
method RuntimeStringCmp (line 38) | RuntimeStringCmp (cmp_mode m=normal) : mode(m) {
function main (line 65) | int main()
function fillAndPrint (line 79) | void fillAndPrint(StringStringMap& coll)
FILE: stl侯杰源码/cont/mapfind.cpp
class value_equals (line 19) | class value_equals {
method value_equals (line 24) | value_equals (const V& v)
function main (line 33) | int main()
FILE: stl侯杰源码/cont/mmap1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/mset1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/newkey.hpp
type MyLib (line 11) | namespace MyLib {
function replace_key (line 13) | inline
FILE: stl侯杰源码/cont/pqueue1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/cont/print.hpp
function PRINT_ELEMENTS (line 19) | inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
FILE: stl侯杰源码/cont/queue1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/cont/queue2.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/cont/refsem1.cpp
function printCountedPtr (line 18) | void printCountedPtr (CountedPtr<int> elem)
function main (line 23) | int main()
FILE: stl侯杰源码/cont/set1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/cont/set2.cpp
function main (line 15) | int main ()
FILE: stl侯杰源码/cont/setcmp.cpp
class RuntimeCmp (line 18) | class RuntimeCmp {
type cmp_mode (line 20) | enum cmp_mode {normal, reverse}
method RuntimeCmp (line 26) | RuntimeCmp (cmp_mode m=normal) : mode(m) {
function main (line 44) | int main()
function fill (line 76) | void fill (IntSet& set)
FILE: stl侯杰源码/cont/sortset.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/cont/sortvec.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/cont/stack1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/cont/stack2.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/cont/vector1.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/fo/compose1.cpp
function main (line 20) | int main()
FILE: stl侯杰源码/fo/compose10.hpp
class compose_f_g_t (line 17) | class compose_f_g_t
method compose_f_g_t (line 25) | compose_f_g_t(const OP1& o1, const OP2& o2)
function compose_f_g (line 39) | inline compose_f_g_t<OP1,OP2>
FILE: stl侯杰源码/fo/compose11.hpp
class compose_f_gx_t (line 16) | class compose_f_gx_t
method compose_f_gx_t (line 25) | compose_f_gx_t(const OP1& o1, const OP2& o2)
function compose_f_gx (line 39) | inline compose_f_gx_t<OP1,OP2>
FILE: stl侯杰源码/fo/compose12.hpp
class compose_f_gxy_t (line 16) | class compose_f_gxy_t
method compose_f_gxy_t (line 26) | compose_f_gxy_t (const OP1& o1, const OP2& o2)
function compose_f_gxy (line 41) | inline compose_f_gxy_t<OP1,OP2>
FILE: stl侯杰源码/fo/compose2.cpp
function main (line 19) | int main()
FILE: stl侯杰源码/fo/compose21.hpp
class compose_f_gx_hx_t (line 16) | class compose_f_gx_hx_t
method compose_f_gx_hx_t (line 26) | compose_f_gx_hx_t (const OP1& o1, const OP2& o2, const OP3& o3)
function compose_f_gx_hx (line 40) | inline compose_f_gx_hx_t<OP1,OP2,OP3>
FILE: stl侯杰源码/fo/compose22.hpp
class compose_f_gx_hy_t (line 16) | class compose_f_gx_hy_t
method compose_f_gx_hy_t (line 27) | compose_f_gx_hy_t (const OP1& o1, const OP2& o2, const OP3& o3)
function compose_f_gx_hy (line 42) | inline compose_f_gx_hy_t<OP1,OP2,OP3>
FILE: stl侯杰源码/fo/compose3.cpp
function main (line 19) | int main()
FILE: stl侯杰源码/fo/compose4.cpp
function main (line 21) | int main()
FILE: stl侯杰源码/fo/fopow.hpp
type fopow (line 15) | struct fopow : public std::binary_function<T1, T2, T1>
method T1 (line 17) | T1 operator() (T1 base, T2 exp) const {
FILE: stl侯杰源码/fo/fopow1.cpp
function main (line 20) | int main()
FILE: stl侯杰源码/fo/foreach3.cpp
class MeanValue (line 17) | class MeanValue {
method MeanValue (line 23) | MeanValue () : num(0), sum(0) {
method value (line 34) | double value () {
function main (line 39) | int main()
FILE: stl侯杰源码/fo/genera1.cpp
class IntSequence (line 17) | class IntSequence {
method IntSequence (line 22) | IntSequence (int initialValue)
function main (line 32) | int main()
FILE: stl侯杰源码/fo/genera2.cpp
class IntSequence (line 17) | class IntSequence {
method IntSequence (line 22) | IntSequence (int initialValue)
function main (line 32) | int main()
FILE: stl侯杰源码/fo/memfun1.cpp
class Person (line 19) | class Person {
method print (line 24) | void print () const {
method printWithPrefix (line 27) | void printWithPrefix (std::string prefix) const {
function foo (line 32) | void foo (const std::vector<Person>& coll)
function ptrfoo (line 50) | void ptrfoo (const std::vector<Person*>& coll)
function main (line 69) | int main()
FILE: stl侯杰源码/fo/nullary.hpp
type boost (line 11) | namespace boost {
type nullary_function (line 18) | struct nullary_function {
class pointer_to_nullary_function (line 26) | class pointer_to_nullary_function : public nullary_function<Result>
method pointer_to_nullary_function (line 31) | pointer_to_nullary_function() {
method pointer_to_nullary_function (line 33) | explicit pointer_to_nullary_function(Result (*x)()) : ptr(x) {
method Result (line 35) | Result operator()() const {
function ptr_fun (line 41) | inline pointer_to_nullary_function<Result> ptr_fun(Result (*x)())
FILE: stl侯杰源码/fo/print.hpp
function PRINT_ELEMENTS (line 19) | inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
FILE: stl侯杰源码/fo/removeif.cpp
class Nth (line 17) | class Nth { // function object that returns true for the nth call
method Nth (line 22) | Nth (int n) : nth(n), count(0) {
function main (line 29) | int main()
FILE: stl侯杰源码/fo/sort1.cpp
class Person (line 21) | class Person {
method Person (line 26) | Person() {
method Person (line 28) | Person(const string& f, const string& n)
function string (line 36) | inline string Person::firstname() const {
function string (line 40) | inline string Person::lastname() const {
function ostream (line 44) | ostream& operator<< (ostream& s, const Person& p)
class PersonSortCriterion (line 54) | class PersonSortCriterion {
function main (line 68) | int main()
FILE: stl侯杰源码/i18n/loc1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/i18n/loc2.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/i18n/numget.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/io/cat1.cpp
function main (line 19) | int main (int argc, char* argv[])
FILE: stl侯杰源码/io/cat2.cpp
function printFileTwice (line 15) | void printFileTwice (const char* filename)
function main (line 30) | int main (int argc, char* argv[])
FILE: stl侯杰源码/io/charcat1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/charcat2.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/io/charset.cpp
function main (line 22) | int main ()
function writeCharsetToFile (line 28) | void writeCharsetToFile (const string& filename)
function outputFile (line 49) | void outputFile (const string& filename)
FILE: stl侯杰源码/io/copy1.cpp
function main (line 13) | int main ()
FILE: stl侯杰源码/io/copy2.cpp
function main (line 13) | int main ()
FILE: stl侯杰源码/io/countlines.cpp
function main (line 18) | int main (int argc, char* argv[])
function countLines (line 44) | int countLines (std::istream& in)
FILE: stl侯杰源码/io/ignore1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/ignoreparam.hpp
class Ignore (line 15) | class Ignore {
method Ignore (line 18) | Ignore(int n) : num(n) {
function Ignore (line 23) | Ignore ignore(int n)
method Ignore (line 18) | Ignore(int n) : num(n) {
FILE: stl侯杰源码/io/ignoreparam1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/inbuf1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/inbuf1.hpp
class inbuf (line 22) | class inbuf : public std::streambuf {
method inbuf (line 36) | inbuf() {
method int_type (line 43) | virtual int_type underflow () {
FILE: stl侯杰源码/io/io1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/io/outbuf1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/outbuf1.hpp
class outbuf (line 15) | class outbuf : public std::streambuf
method int_type (line 21) | virtual int_type overflow (int_type c) {
FILE: stl侯杰源码/io/outbuf1x.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/outbuf1x.hpp
class basic_outbuf (line 16) | class basic_outbuf : public std::basic_streambuf<charT,traits>
method overflow (line 22) | virtual typename traits::int_type
FILE: stl侯杰源码/io/outbuf2.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/outbuf2.hpp
class fdoutbuf (line 22) | class fdoutbuf : public std::streambuf {
method fdoutbuf (line 27) | fdoutbuf (int _fd) : fd(_fd) {
method int_type (line 31) | virtual int_type overflow (int_type c) {
method xsputn (line 41) | virtual std::streamsize xsputn (const char* s,
class fdostream (line 47) | class fdostream : public std::ostream {
method fdostream (line 51) | fdostream (int fd) : std::ostream(0), buf(fd) {
FILE: stl侯杰源码/io/outbuf3.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/io/outbuf3.hpp
class outbuf (line 21) | class outbuf : public std::streambuf {
method outbuf (line 32) | outbuf() {
method flushBuffer (line 45) | int flushBuffer () {
method int_type (line 57) | virtual int_type overflow (int_type c) {
method sync (line 74) | virtual int sync () {
FILE: stl侯杰源码/io/rdbuf1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/io/rdbuf2.cpp
function hexMultiplicationTable (line 14) | void hexMultiplicationTable (std::streambuf* buffer, int num)
function main (line 28) | int main()
FILE: stl侯杰源码/io/redirect.cpp
function main (line 17) | int main()
function redirect (line 26) | void redirect (ostream& strm)
FILE: stl侯杰源码/io/rw1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/io/sstr1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/io/sum1.cpp
type MyLib (line 14) | namespace MyLib {
function readAndProcessSum (line 46) | double readAndProcessSum (std::istream& strm)
function main (line 18) | int main()
type MyLib (line 45) | namespace MyLib {
function readAndProcessSum (line 46) | double readAndProcessSum (std::istream& strm)
FILE: stl侯杰源码/io/sum2.cpp
type MyLib (line 14) | namespace MyLib {
function readAndProcessSum (line 46) | double readAndProcessSum (std::istream& strm)
function main (line 18) | int main()
type MyLib (line 45) | namespace MyLib {
function readAndProcessSum (line 46) | double readAndProcessSum (std::istream& strm)
FILE: stl侯杰源码/iter/advance1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/iter/advance2.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/iter/assoiter.cpp
function main (line 20) | int main()
FILE: stl侯杰源码/iter/assoiter.hpp
class asso_insert_iterator (line 16) | class asso_insert_iterator
method asso_insert_iterator (line 25) | explicit asso_insert_iterator (Container& c) : container(c) {
function asso_inserter (line 53) | inline asso_insert_iterator<Container> asso_inserter (Container& c)
FILE: stl侯杰源码/iter/backins.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/iter/distance.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/iter/distance.hpp
function distance (line 12) | inline long distance (Iterator pos1, Iterator pos2)
FILE: stl侯杰源码/iter/frontins.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/iter/inserter.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/iter/istriter.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/iter/itercat.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/iter/ostriter.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/iter/print.hpp
function PRINT_ELEMENTS (line 19) | inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
FILE: stl侯杰源码/iter/reviter1.cpp
function print (line 16) | void print (int elem)
function main (line 21) | int main()
FILE: stl侯杰源码/iter/reviter2.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/iter/reviter3.cpp
function print (line 16) | void print (int elem)
function main (line 21) | int main()
FILE: stl侯杰源码/iter/reviter4.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/iter/swap1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/memory/myalloc.hpp
type MyLib (line 14) | namespace MyLib {
class MyAlloc (line 16) | class MyAlloc {
type rebind (line 29) | struct rebind {
method pointer (line 34) | pointer address (reference value) const {
method const_pointer (line 37) | const_pointer address (const_reference value) const {
method MyAlloc (line 44) | MyAlloc() throw() {
method MyAlloc (line 46) | MyAlloc(const MyAlloc&) throw() {
method MyAlloc (line 49) | MyAlloc (const MyAlloc<U>&) throw() {
method size_type (line 55) | size_type max_size () const throw() {
method pointer (line 60) | pointer allocate (size_type num, const void* = 0) {
method construct (line 70) | void construct (pointer p, const T& value) {
method destroy (line 76) | void destroy (pointer p) {
method deallocate (line 82) | void deallocate (pointer p, size_type num) {
FILE: stl侯杰源码/memory/myalloc1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/num/complex1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/num/complex2.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/num/gslice1.cpp
function printValarray3D (line 17) | void printValarray3D (const valarray<T>& va, int dim1, int dim2)
function main (line 31) | int main()
FILE: stl侯杰源码/num/indi1.cpp
function printValarray (line 17) | void printValarray (const valarray<T>& va, int num)
function main (line 28) | int main()
FILE: stl侯杰源码/num/masked1.cpp
function printValarray (line 17) | void printValarray (const valarray<T>& va, int num)
function main (line 28) | int main()
FILE: stl侯杰源码/num/slice1.cpp
function printValarray (line 17) | void printValarray (const valarray<T>& va, int num)
function main (line 28) | int main()
FILE: stl侯杰源码/num/val1.cpp
function printValarray (line 17) | void printValarray (const valarray<T>& va)
function main (line 25) | int main()
FILE: stl侯杰源码/num/val2.cpp
function printValarray (line 17) | void printValarray (const valarray<T>& va)
function main (line 25) | int main()
FILE: stl侯杰源码/stl/add1.cpp
class AddValue (line 18) | class AddValue {
method AddValue (line 23) | AddValue(int v) : theValue(v) {
function main (line 32) | int main()
FILE: stl侯杰源码/stl/algo1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/copy1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/stl/copy2.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/stl/copy3.cpp
function main (line 19) | int main()
FILE: stl侯杰源码/stl/deque1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/stl/find1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/fo1.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/stl/foreach1.cpp
function print (line 17) | void print (int elem)
function main (line 22) | int main()
FILE: stl侯杰源码/stl/foreach2.cpp
class PrintInt (line 17) | class PrintInt {
function main (line 24) | int main()
FILE: stl侯杰源码/stl/ioiter1.cpp
function main (line 18) | int main()
FILE: stl侯杰源码/stl/iterbug1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/list1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/stl/list2.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/stl/map1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/mmap1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/prime1.cpp
function isPrime (line 18) | bool isPrime (int number)
function main (line 38) | int main()
FILE: stl侯杰源码/stl/print.hpp
function PRINT_ELEMENTS (line 19) | inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
FILE: stl侯杰源码/stl/remove1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/stl/remove2.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/stl/remove3.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/stl/remove4.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/stl/riter1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/stl/set1.cpp
function main (line 14) | int main()
FILE: stl侯杰源码/stl/sort1.cpp
class Person (line 21) | class Person {
method Person (line 26) | Person() {
method Person (line 28) | Person(const string& f, const string& n)
function string (line 36) | inline string Person::firstname() const {
function string (line 40) | inline string Person::lastname() const {
function ostream (line 44) | ostream& operator<< (ostream& s, const Person& p)
function personSortCriterion (line 54) | bool personSortCriterion (const Person& p1, const Person& p2)
function main (line 65) | int main()
FILE: stl侯杰源码/stl/transform1.cpp
function square (line 17) | int square (int value)
function main (line 22) | int main()
FILE: stl侯杰源码/stl/vector1.cpp
function main (line 15) | int main()
FILE: stl侯杰源码/string/icstring.hpp
type ignorecase_traits (line 21) | struct ignorecase_traits : public std::char_traits<char> {
method eq (line 23) | static bool eq(const char& c1, const char& c2) {
method lt (line 27) | static bool lt(const char& c1, const char& c2) {
method compare (line 31) | static int compare(const char* s1, const char* s2,
FILE: stl侯杰源码/string/icstring1.cpp
function main (line 13) | int main()
FILE: stl侯杰源码/string/iter1.cpp
function main (line 17) | int main()
FILE: stl侯杰源码/string/iter2.cpp
function nocase_compare (line 16) | bool nocase_compare (char c1, char c2)
function main (line 21) | int main()
FILE: stl侯杰源码/string/iter3.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/string/string1.cpp
function main (line 15) | int main (int argc, char* argv[])
FILE: stl侯杰源码/string/string2.cpp
function main (line 15) | int main (int argc, char** argv)
FILE: stl侯杰源码/string/unique.cpp
class bothWhiteSpaces (line 18) | class bothWhiteSpaces {
method bothWhiteSpaces (line 25) | bothWhiteSpaces (const locale& l) : loc(l) {
function main (line 35) | int main()
FILE: stl侯杰源码/util/autoptr.hpp
type std (line 14) | namespace std {
type auto_ptr_ref (line 17) | struct auto_ptr_ref {
method auto_ptr_ref (line 19) | auto_ptr_ref (Y* rhs)
class auto_ptr (line 25) | class auto_ptr {
method auto_ptr (line 32) | explicit auto_ptr (T* ptr = 0) throw()
method auto_ptr (line 38) | auto_ptr (auto_ptr& rhs) throw()
method auto_ptr (line 42) | auto_ptr (auto_ptr<Y>& rhs) throw()
method auto_ptr (line 48) | auto_ptr& operator= (auto_ptr& rhs) throw() {
method auto_ptr (line 53) | auto_ptr& operator= (auto_ptr<Y>& rhs) throw() {
method T (line 64) | T* get() const throw() {
method T (line 67) | T& operator*() const throw() {
method T (line 70) | T* operator->() const throw() {
method T (line 75) | T* release() throw() {
method reset (line 82) | void reset (T* ptr=0) throw() {
method auto_ptr (line 91) | auto_ptr(auto_ptr_ref<T> rhs) throw()
method auto_ptr (line 94) | auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() { // new
FILE: stl侯杰源码/util/autoptr1.cpp
function ostream (line 19) | ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
function main (line 31) | int main()
FILE: stl侯杰源码/util/autoptr2.cpp
function ostream (line 19) | ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
function main (line 31) | int main()
FILE: stl侯杰源码/util/defalloc.hpp
type std (line 11) | namespace std {
class allocator (line 13) | class allocator {
type rebind (line 26) | struct rebind {
method pointer (line 31) | pointer address (reference value) const {
method const_pointer (line 34) | const_pointer address (const_reference value) const {
method allocator (line 41) | allocator() throw() {
method allocator (line 43) | allocator(const allocator&) throw() {
method allocator (line 46) | allocator (const allocator<U>&) throw() {
method size_type (line 52) | size_type max_size () const throw() {
method pointer (line 57) | pointer allocate (size_type num,
method construct (line 64) | void construct (pointer p, const T& value) {
method destroy (line 70) | void destroy (pointer p) {
method deallocate (line 76) | void deallocate (pointer p, size_type num) {
FILE: stl侯杰源码/util/limits1.cpp
function main (line 16) | int main()
FILE: stl侯杰源码/util/minmax1.cpp
function int_ptr_less (line 16) | bool int_ptr_less (int* a, int* b)
function main (line 21) | int main()
FILE: tass-sgi-stl-2.91.57-source/PlotFile.h
function class (line 48) | class PlotFile : public ofstream
FILE: tass-sgi-stl-2.91.57-source/SFile.h
function class (line 35) | class SFile: public fstream
FILE: tass-sgi-stl-2.91.57-source/builtinbuf.h
function class (line 39) | class builtinbuf : public streambuf {
FILE: tass-sgi-stl-2.91.57-source/defalloc.h
function T (line 37) | T* allocate(ptrdiff_t size, T*) {
function deallocate (line 49) | void deallocate(T* buffer) {
type T (line 57) | typedef T* pointer;
type T (line 58) | typedef const T* const_pointer;
type T (line 59) | typedef T& reference;
type T (line 60) | typedef const T& const_reference;
type size_type (line 61) | typedef size_t size_type;
type difference_type (line 62) | typedef ptrdiff_t difference_type;
function pointer (line 63) | pointer allocate(size_type n) {
function deallocate (line 66) | void deallocate(pointer p) { ::deallocate(p); }
function pointer (line 67) | pointer address(reference x) { return (pointer)&x; }
function const_pointer (line 68) | const_pointer const_address(const_reference x) {
function size_type (line 71) | size_type init_page_size() {
function class (line 79) | class allocator<void> {
FILE: tass-sgi-stl-2.91.57-source/editbuf.h
type mark_pointer (line 36) | typedef unsigned long mark_pointer;
type buf_char (line 39) | typedef /*unsigned*/ char buf_char;
type buf_index (line 42) | typedef long buf_index;
type buf_offset (line 45) | typedef long buf_offset;
type buf_cookie (line 48) | struct buf_cookie {
type edit_buffer (line 56) | struct edit_buffer
type edit_mark (line 57) | struct edit_mark
type edit_string (line 63) | struct edit_string {
type edit_string (line 75) | struct edit_string
function streambuf (line 78) | struct edit_streambuf : public streambuf {
type edit_mark (line 109) | struct edit_mark {
function index_in_buffer (line 113) | long index_in_buffer(struct edit_buffer *)
type edit_buffer (line 115) | struct edit_buffer
type edit_string (line 118) | struct edit_string
type edit_buffer (line 136) | struct edit_buffer {
type edit_streambuf (line 145) | struct edit_streambuf
type edit_mark (line 146) | struct edit_mark
type edit_mark (line 147) | struct edit_mark
function buf_offset (line 149) | inline buf_offset gap_end_pos() { return __gap_end_pos; }
type edit_mark (line 150) | struct edit_mark
type edit_mark (line 151) | struct edit_mark
function buf_char (line 155) | inline buf_char *gap_end() { return data + gap_end_pos(); }
function gap_size (line 156) | inline int gap_size() { return gap_end() - gap_start(); }
function size1 (line 157) | inline int size1() { return gap_start() - data; }
function size2 (line 158) | inline int size2() { return buf_size - gap_end_pos(); }
type edit_mark (line 159) | struct edit_mark
function move_gap (line 162) | void move_gap (buf_char *pos) { move_gap(pos - data); }
type edit_mark (line 168) | struct edit_mark
type edit_mark (line 168) | struct edit_mark
type edit_string (line 171) | struct edit_string
function buf_char (line 175) | inline buf_char *edit_mark::ptr(struct edit_buffer *buf)
function flush_to_buffer (line 178) | inline void edit_streambuf::flush_to_buffer()
FILE: tass-sgi-stl-2.91.57-source/fstream.h
function class (line 33) | class fstreambase : virtual public ios {
function fstreambase (line 62) | ifstream(int fd) : fstreambase(fd) { }
function fstreambase (line 73) | ofstream(int fd) : fstreambase(fd) { }
function fstreambase (line 84) | fstream(int fd) : fstreambase(fd) { }
FILE: tass-sgi-stl-2.91.57-source/indstream.h
function class (line 52) | class indirectbuf : public streambuf {
FILE: tass-sgi-stl-2.91.57-source/iolibio.h
type obstack (line 36) | struct obstack
type obstack (line 37) | struct obstack
type obstack (line 39) | struct obstack
FILE: tass-sgi-stl-2.91.57-source/iostdio.h
type _IO_FILE (line 37) | typedef _IO_FILE FILE;
FILE: tass-sgi-stl-2.91.57-source/iostream.h
function class (line 44) | class ostream : virtual public ios
function streambuf (line 110) | streambuf* ostreambuf() const { return _strbuf; }
function class (line 114) | class istream : virtual public ios
function class (line 233) | class _IO_istream_withassign : public istream {
function class (line 240) | class _IO_ostream_withassign : public ostream {
type Iostream_init (line 262) | struct Iostream_init { }
FILE: tass-sgi-stl-2.91.57-source/libio.h
type _IO_jump_t (line 152) | struct _IO_jump_t
type _IO_FILE (line 152) | struct _IO_FILE
type _IO_lock_t (line 168) | typedef void _IO_lock_t;
type _IO_lock_t (line 172) | struct _IO_lock_t { void *ptr; short int field1; short int field2; }
type _IO_lock_t (line 175) | typedef void _IO_lock_t;
type _IO_marker (line 183) | struct _IO_marker {
type _IO_FILE (line 202) | struct _IO_FILE {
type _IO_FILE (line 251) | typedef struct _IO_FILE _IO_FILE;
type _IO_FILE_plus (line 260) | struct _IO_FILE_plus
type _IO_FILE_plus (line 261) | struct _IO_FILE_plus
type _IO_cookie_io_functions_t (line 268) | typedef struct
type _IO_cookie_file (line 277) | struct _IO_cookie_file
FILE: tass-sgi-stl-2.91.57-source/libioP.h
type _IO_size_t (line 125) | typedef _IO_size_t (*_IO_xsputn_t)
type _IO_size_t (line 132) | typedef _IO_size_t (*_IO_xsgetn_t)
type _IO_fpos64_t (line 142) | typedef _IO_fpos64_t (*_IO_seekoff_t)
type _IO_fpos_t (line 145) | typedef _IO_fpos_t (*_IO_seekoff_t)
type _IO_fpos64_t (line 156) | typedef _IO_fpos64_t (*_IO_seekpos_t)
type _IO_fpos_t (line 158) | typedef _IO_fpos_t (*_IO_seekpos_t)
type _IO_FILE (line 164) | typedef _IO_FILE* (*_IO_setbuf_t)
type _IO_ssize_t (line 194) | typedef _IO_ssize_t (*_IO_read_t)
type _IO_ssize_t (line 201) | typedef _IO_ssize_t (*_IO_write_t)
type _IO_fpos64_t (line 209) | typedef _IO_fpos64_t (*_IO_seek_t)
type _IO_fpos_t (line 211) | typedef _IO_fpos_t (*_IO_seek_t)
type _IO_jump_t (line 246) | struct _IO_jump_t
type _IO_FILE_plus (line 285) | struct _IO_FILE_plus
type _IO_marker (line 317) | struct _IO_marker
type _IO_marker (line 318) | struct _IO_marker
type _IO_marker (line 319) | struct _IO_marker
type _IO_marker (line 320) | struct _IO_marker
type _IO_marker (line 321) | struct _IO_marker
type _IO_marker (line 322) | struct _IO_marker
type _IO_jump_t (line 356) | struct _IO_jump_t
type _IO_jump_t (line 357) | struct _IO_jump_t
type _IO_jump_t (line 358) | struct _IO_jump_t
type _IO_jump_t (line 359) | struct _IO_jump_t
type stat (line 527) | struct stat
type stat (line 532) | struct stat
type _IO_fake_stdiobuf (line 616) | struct _IO_fake_stdiobuf
FILE: tass-sgi-stl-2.91.57-source/parsestream.h
function class (line 43) | class parsebuf : public streambuf {
function class (line 83) | class string_parsebuf : public parsebuf {
function class (line 114) | class func_parsebuf : public parsebuf {
function class (line 129) | class general_parsebuf : public parsebuf {
function class (line 142) | class parsestream : public istream {
FILE: tass-sgi-stl-2.91.57-source/pfstream.h
function class (line 42) | class ipfstream : public ifstream {
function class (line 53) | class opfstream : public ofstream {
FILE: tass-sgi-stl-2.91.57-source/procbuf.h
function class (line 36) | class procbuf : public filebuf {
FILE: tass-sgi-stl-2.91.57-source/ropeimpl.h
function o (line 815) | o(writer) {}
function __rope_fill (line 908) | inline void __rope_fill(ostream& o, size_t n)
function rotate (line 1507) | inline void rotate(__rope_iterator<char,__ALLOC> first,
function rotate (line 1521) | inline void rotate(__rope_iterator<wchar_t,__ALLOC> first,
FILE: tass-sgi-stl-2.91.57-source/std/bastring.cc
function charT (line 68) | charT * basic_string <charT, traits, Allocator>::Rep::
function istream (line 432) | istream &
function ostream (line 467) | ostream &
function istream (line 474) | istream&
FILE: tass-sgi-stl-2.91.57-source/std/bastring.h
type Rep (line 69) | struct Rep {
function charT (line 75) | charT* grab () { if (selfish) return clone (); ++ref; return data (); }
function release (line 76) | void release () { if (--ref == 0) delete this; }
type typename (line 97) | typedef typename traits::char_type value_type;
type Allocator (line 98) | typedef Allocator allocator_type;
type size_type (line 100) | typedef size_t size_type;
type difference_type (line 101) | typedef ptrdiff_t difference_type;
type charT (line 102) | typedef charT& reference;
type charT (line 103) | typedef const charT& const_reference;
type charT (line 104) | typedef charT* pointer;
type charT (line 105) | typedef const charT* const_pointer;
type pointer (line 106) | typedef pointer iterator;
type const_pointer (line 107) | typedef const_pointer const_iterator;
type reverse_iterator (line 108) | typedef ::reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 109) | typedef ::reverse_iterator<const_iterator> const_reverse_iterator;
function repup (line 114) | void repup (Rep *p) { rep ()->release (); dat = p->data (); }
function explicit (line 137) | explicit basic_string (): dat (nilRep.grab ()) { }
function dat (line 143) | basic_string (const charT* s)
function swap (line 158) | void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; }
function iterator (line 215) | iterator insert(iterator p, charT c)
function iterator (line 219) | iterator insert(iterator p, size_type n, charT c)
function insert (line 227) | void insert(iterator p, const_iterator first, const_iterator last)
function iterator (line 233) | iterator erase(iterator p)
function iterator (line 237) | iterator erase(iterator f, iterator l)
function unique (line 270) | void unique () { if (rep ()->ref > 1) alloc (length (), true); }
function selfish (line 271) | void selfish () { unique (); rep ()->selfish = true; }
function reference (line 281) | reference operator[] (size_type pos)
function reference (line 284) | reference at (size_type pos)
function const_reference (line 289) | const_reference at (size_type pos) const
function resize (line 303) | void resize (size_type n)
function reserve (line 305) | void reserve (size_type) { }
function size_type (line 316) | size_type rfind (const basic_string& str, size_type pos = npos) const
function size_type (line 319) | size_type rfind (const charT* s, size_type pos = npos) const
function size_type (line 331) | size_type find_last_of (const basic_string& str, size_type pos = npos) c...
function size_type (line 334) | size_type find_last_of (const charT* s, size_type pos = npos) const
function size_type (line 336) | size_type find_last_of (charT c, size_type pos = npos) const
function size_type (line 346) | size_type find_last_not_of (const basic_string& str, size_type pos = npo...
function size_type (line 349) | size_type find_last_not_of (const charT* s, size_type pos = npos) const
function iterator (line 362) | iterator begin () { selfish (); return &(*this)[0]; }
function iterator (line 363) | iterator end () { selfish (); return &(*this)[length ()]; }
function reverse_iterator (line 373) | reverse_iterator rbegin() { return reverse_iterator (end ()); }
function const_reverse_iterator (line 374) | const_reverse_iterator rbegin() const
FILE: tass-sgi-stl-2.91.57-source/std/complext.cc
function cos (line 31) | complex<FLOAT>
function cosh (line 38) | complex<FLOAT>
function exp (line 45) | complex<FLOAT>
function log (line 51) | complex<FLOAT>
function pow (line 57) | complex<FLOAT>
function pow (line 67) | complex<FLOAT>
function pow (line 73) | complex<FLOAT>
function sin (line 79) | complex<FLOAT>
function sinh (line 86) | complex<FLOAT>
function istream (line 95) | istream&
function ostream (line 123) | ostream&
function pow (line 229) | complex<FLOAT>
function sqrt (line 252) | complex<FLOAT>
FILE: tass-sgi-stl-2.91.57-source/std/complext.h
function _FLT (line 135) | _FLT
function _FLT (line 144) | _FLT
function _FLT (line 319) | _FLT
function _FLT (line 328) | _FLT
function _FLT (line 355) | _FLT
FILE: tass-sgi-stl-2.91.57-source/std/dcomplex.h
function class (line 36) | class complex<double>
function complex (line 86) | inline complex<float>::complex (const complex<double>& r)
FILE: tass-sgi-stl-2.91.57-source/std/fcomplex.h
function class (line 36) | class complex<float>
FILE: tass-sgi-stl-2.91.57-source/std/ldcomplex.h
function class (line 36) | class complex<long double>
function complex (line 86) | inline complex<float>::complex (const complex<long double>& r)
function complex (line 90) | inline complex<double>::complex (const complex<long double>& r)
FILE: tass-sgi-stl-2.91.57-source/std/straits.h
type charT (line 41) | typedef charT char_type;
function assign (line 45) | static void assign (char_type& c1, const char_type& c2)
function eq (line 47) | static bool eq (const char_type& c1, const char_type& c2)
function ne (line 49) | static bool ne (const char_type& c1, const char_type& c2)
function lt (line 51) | static bool lt (const char_type& c1, const char_type& c2)
function char_type (line 53) | static char_type eos () { return char_type(); }
function is_del (line 54) | static bool is_del(char_type a) { return 0; }
function compare (line 59) | static int compare (const char_type* s1, const char_type* s2, size_t n)
function length (line 69) | static size_t length (const char_type* s)
function char_type (line 77) | static char_type* copy (char_type* s1, const char_type* s2, size_t n)
function char_type (line 84) | static char_type* move (char_type* s1, const char_type* s2, size_t n)
function char_type (line 95) | static char_type* set (char_type* s1, const char_type& c, size_t n)
function char (line 108) | struct string_char_traits <char> {
type string_char_traits (line 136) | struct string_char_traits
type wchar_t (line 137) | typedef wchar_t char_type;
function assign (line 139) | static void assign (char_type& c1, const char_type& c2)
function eq (line 141) | static bool eq (const char_type & c1, const char_type& c2)
function ne (line 143) | static bool ne (const char_type& c1, const char_type& c2)
function lt (line 145) | static bool lt (const char_type& c1, const char_type& c2)
function char_type (line 147) | static char_type eos () { return 0; }
function is_del (line 148) | static bool is_del(char_type a) { return iswspace(a); }
function compare (line 150) | static int compare (const char_type* s1, const char_type* s2, size_t n)
function length (line 152) | static size_t length (const char_type* s)
function char_type (line 154) | static char_type* copy (char_type* s1, const char_type* s2, size_t n)
function char_type (line 156) | static char_type* set (char_type* s1, const char_type& c, size_t n)
FILE: tass-sgi-stl-2.91.57-source/stdiostream.h
function class (line 38) | class stdiobuf : public filebuf {
function class (line 56) | class istdiostream : public istream
function class (line 67) | class ostdiostream : public ostream
FILE: tass-sgi-stl-2.91.57-source/stl_algo.h
function ForwardIterator1 (line 193) | ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
function ForwardIterator1 (line 234) | ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
function OutputIterator (line 431) | OutputIterator __unique_copy(InputIterator first, InputIterator last,
function OutputIterator (line 438) | OutputIterator unique_copy(InputIterator first, InputIterator last,
function OutputIterator (line 470) | OutputIterator __unique_copy(InputIterator first, InputIterator last,
function OutputIterator (line 478) | OutputIterator unique_copy(InputIterator first, InputIterator last,
function reverse (line 516) | void reverse(BidirectionalIterator first, BidirectionalIterator last) {
function RandomAccessIterator (line 732) | RandomAccessIterator
function RandomAccessIterator (line 741) | RandomAccessIterator
function ForwardIterator (line 835) | ForwardIterator __stable_partition_aux(ForwardIterator first,
function ForwardIterator (line 849) | ForwardIterator stable_partition(ForwardIterator first,
function __linear_insert (line 916) | void __linear_insert(RandomAccessIterator first,
function __linear_insert (line 928) | void __linear_insert(RandomAccessIterator first,
function __unguarded_insertion_sort (line 976) | void __unguarded_insertion_sort(RandomAccessIterator first,
function Size (line 1005) | Size __lg(Size n) {
function sort (line 1048) | void sort(RandomAccessIterator first, RandomAccessIterator last) {
function sort (line 1056) | void sort(RandomAccessIterator first, RandomAccessIterator last,
function stable_sort (line 1255) | void stable_sort(RandomAccessIterator first,
function partial_sort (line 1289) | void partial_sort(RandomAccessIterator first,
function RandomAccessIterator (line 1321) | RandomAccessIterator
function RandomAccessIterator (line 1356) | RandomAccessIterator
function nth_element (line 1401) | void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
function ForwardIterator (line 1452) | ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
function ForwardIterator (line 1505) | ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
function ForwardIterator (line 1557) | ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
function ForwardIterator (line 1610) | ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
function else (line 1990) | else if (len2 <= buffer_size) {
function __inplace_merge_aux (line 2022) | void __inplace_merge_aux(BidirectionalIterator first,
function __inplace_merge_aux (line 2039) | void __inplace_merge_aux(BidirectionalIterator first,
function inplace_merge (line 2058) | void inplace_merge(BidirectionalIterator first,
function inplace_merge (line 2067) | void inplace_merge(BidirectionalIterator first,
type reverse_iterator (line 2504) | typedef reverse_iterator<BidirectionalIterator2> reviter2;
type reverse_iterator (line 2528) | typedef reverse_iterator<BidirectionalIterator2> reviter2;
function ForwardIterator1 (line 2548) | ForwardIterator1
function ForwardIterator1 (line 2566) | ForwardIterator1
FILE: tass-sgi-stl-2.91.57-source/stl_algobase.h
function iter_swap (line 69) | void iter_swap(ForwardIterator1 a, ForwardIterator2 b) {
function OutputIterator (line 108) | OutputIterator __copy(InputIterator first, InputIterator last,
function OutputIterator (line 117) | OutputIterator
function OutputIterator (line 127) | OutputIterator
function OutputIterator (line 137) | OutputIterator operator()(InputIterator first, InputIterator last,
function T (line 146) | T* __copy_t(const T* first, const T* last, T* result, __true_type) {
function T (line 152) | T* __copy_t(const T* first, const T* last, T* result, __false_type) {
type typename (line 160) | typedef typename __type_traits<T>::has_trivial_assignment_operator t;
type typename (line 169) | typedef typename __type_traits<T>::has_trivial_assignment_operator t;
function OutputIterator (line 177) | OutputIterator copy(InputIterator first, InputIterator last,
function wchar_t (line 188) | inline wchar_t* copy(const wchar_t* first, const wchar_t* last,
function BidirectionalIterator2 (line 195) | BidirectionalIterator2 __copy_backward(BidirectionalIterator1 first,
function BidirectionalIterator2 (line 206) | BidirectionalIterator2 operator()(BidirectionalIterator1 first,
function T (line 216) | T* __copy_backward_t(const T* first, const T* last, T* result,
function T (line 224) | T* __copy_backward_t(const T* first, const T* last, T* result,
type typename (line 233) | typedef typename __type_traits<T>::has_trivial_assignment_operator t;
type typename (line 242) | typedef typename __type_traits<T>::has_trivial_assignment_operator t;
function BidirectionalIterator2 (line 250) | BidirectionalIterator2 copy_backward(BidirectionalIterator1 first,
function equal (line 321) | bool equal(InputIterator1 first1, InputIterator1 last1,
function equal (line 330) | bool equal(InputIterator1 first1, InputIterator1 last1,
function lexicographical_compare (line 363) | inline bool
function lexicographical_compare (line 375) | inline bool lexicographical_compare(const char* first1, const char* last1,
function lexicographical_compare_3way (line 407) | inline int
function lexicographical_compare_3way (line 419) | inline int lexicographical_compare_3way(const char* first1, const char* ...
FILE: tass-sgi-stl-2.91.57-source/stl_alloc.h
function deallocate (line 156) | static void deallocate(void *p, size_t /* n */)
type __malloc_alloc_template (line 214) | typedef __malloc_alloc_template<0> malloc_alloc;
function T (line 222) | static T *allocate(void)
function deallocate (line 224) | static void deallocate(T *p, size_t n)
function deallocate (line 226) | static void deallocate(T *p)
function deallocate (line 253) | static void deallocate(void *p, size_t n)
type malloc_alloc (line 276) | typedef malloc_alloc alloc;
type malloc_alloc (line 277) | typedef malloc_alloc single_client_alloc;
function ROUND_UP (line 324) | static size_t ROUND_UP(size_t bytes) {
function FREELIST_INDEX (line 339) | static size_t FREELIST_INDEX(size_t bytes) {
function class (line 380) | class lock {
function deallocate (line 416) | static void deallocate(void *p, size_t n)
type __default_alloc_template (line 440) | typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
type timespec (line 603) | struct timespec
FILE: tass-sgi-stl-2.91.57-source/stl_bvector.h
type __bit_reference (line 42) | struct __bit_reference {
function flip (line 64) | void flip() { *p ^= mask; }
function swap (line 67) | inline void swap(__bit_reference x, __bit_reference y) {
type __bit_iterator (line 73) | struct __bit_iterator
type __bit_reference (line 74) | typedef __bit_reference reference;
type __bit_reference (line 75) | typedef __bit_reference* pointer;
type __bit_iterator (line 76) | typedef __bit_iterator iterator;
function bump_up (line 80) | void bump_up() {
function bump_down (line 86) | void bump_down() {
function reference (line 140) | reference operator[](difference_type i) { return *(*this + i); }
function operator (line 147) | bool operator<(iterator x) const {
type __bit_const_iterator (line 152) | struct __bit_const_iterator
type const_reference (line 156) | typedef bool const_reference;
type __bit_const_iterator (line 158) | typedef __bit_const_iterator const_iterator;
function bump_up (line 162) | void bump_up() {
function bump_down (line 168) | void bump_down() {
function const_reference (line 225) | const_reference operator[](difference_type i) {
function const_iterator (line 234) | bool operator<(const_iterator x) const {
type data_allocator (line 263) | typedef simple_alloc<unsigned int, Alloc> data_allocator;
type data_allocator (line 265) | typedef simple_alloc<unsigned int, alloc> data_allocator;
type size_type (line 269) | typedef size_t size_type;
type difference_type (line 270) | typedef ptrdiff_t difference_type;
type __bit_reference (line 271) | typedef __bit_reference reference;
type const_reference (line 272) | typedef bool const_reference;
type __bit_reference (line 273) | typedef __bit_reference* pointer;
type __bit_iterator (line 276) | typedef __bit_iterator iterator;
type __bit_const_iterator (line 277) | typedef __bit_const_iterator const_iterator;
type reverse_iterator (line 280) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 281) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 283) | typedef reverse_iterator<const_iterator, value_type, const_reference,
type reverse_iterator (line 285) | typedef reverse_iterator<iterator, value_type, reference, difference_type>
function deallocate (line 296) | void deallocate() {
function initialize (line 300) | void initialize(size_type n) {
function insert_aux (line 306) | void insert_aux(iterator position, bool x) {
function iterator (line 384) | iterator end() { return finish; }
function reverse_iterator (line 387) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 391) | reverse_iterator rend() { return reverse_iterator(begin()); }
function reference (line 402) | reference operator[](size_type n) {
function const_reference (line 405) | const_reference operator[](size_type n) const {
function explicit (line 421) | explicit __BVECTOR(size_type n) {
function reserve (line 461) | void reserve(size_type n) {
function reference (line 470) | reference front() { return *begin(); }
function reference (line 472) | reference back() { return *(end() - 1); }
function push_back (line 474) | void push_back(bool x) {
function swap (line 480) | void swap(__BVECTOR& x) {
function iterator (line 485) | iterator insert(iterator position, bool x = bool()) {
function insert (line 501) | void insert(iterator position, const_iterator first,
function insert (line 523) | void insert(iterator position, const bool* first, const bool* last) {
function insert (line 545) | void insert(iterator position, size_type n, bool x) {
function insert (line 564) | void insert(iterator pos, int n, bool x) { insert(pos, (size_type)n, x); }
function insert (line 565) | void insert(iterator pos, long n, bool x) { insert(pos, (size_type)n, x); }
function pop_back (line 567) | void pop_back() { --finish; }
function iterator (line 568) | iterator erase(iterator position) {
function iterator (line 574) | iterator erase(iterator first, iterator last) {
function resize (line 578) | void resize(size_type new_size, bool x = bool()) {
function clear (line 584) | void clear() { erase(begin(), end()); }
type vector (line 589) | typedef vector<bool, alloc> bit_vector;
FILE: tass-sgi-stl-2.91.57-source/stl_construct.h
function destroy (line 39) | inline void destroy(T* pointer) {
function construct (line 44) | void construct(T1* p, const T2& value) {
function __destroy_aux (line 49) | void
function __destroy_aux (line 56) | void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}
function __destroy (line 59) | void __destroy(ForwardIterator first, ForwardIterator last, T*) {
function destroy (line 65) | void destroy(ForwardIterator first, ForwardIterator last) {
function destroy (line 69) | inline void destroy(char*, char*) {}
function destroy (line 70) | inline void destroy(wchar_t*, wchar_t*) {}
FILE: tass-sgi-stl-2.91.57-source/stl_deque.h
function __deque_buf_size (line 90) | inline size_t __deque_buf_size(size_t n, size_t sz)
type __deque_iterator (line 98) | typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
type __deque_iterator (line 99) | typedef __deque_iterator<T, const
function buffer_size (line 100) | static size_t buffer_size() {return __deque_buf_size(BufSiz, sizeof(T)); }
type __deque_iterator (line 104) | typedef __deque_iterator<T, T&, T*> iterator;
type __deque_iterator (line 105) | typedef __deque_iterator<T, const
function buffer_size (line 106) | static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); }
type random_access_iterator_tag (line 109) | typedef random_access_iterator_tag iterator_category;
type T (line 110) | typedef T value_type;
type Ptr (line 111) | typedef Ptr pointer;
type Ref (line 112) | typedef Ref reference;
type size_type (line 113) | typedef size_t size_type;
type difference_type (line 114) | typedef ptrdiff_t difference_type;
type T (line 115) | typedef T** map_pointer;
type __deque_iterator (line 117) | typedef __deque_iterator self;
function pointer (line 132) | pointer operator->() const { return &(operator*()); }
function reference (line 194) | reference operator[](difference_type n) const { return *(*this + n); }
function operator (line 196) | bool operator==(const self& x) const { return cur == x.cur; }
function operator (line 197) | bool operator!=(const self& x) const { return !(*this == x); }
function operator (line 198) | bool operator<(const self& x) const {
function set_node (line 202) | void set_node(map_pointer new_node) {
function random_access_iterator_tag (line 214) | random_access_iterator_tag
function T (line 220) | T* value_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
function random_access_iterator_tag (line 232) | random_access_iterator_tag
function T (line 238) | T* value_type(const __deque_iterator<T, Ref, Ptr>&) { return 0; }
type value_type (line 256) | typedef value_type* pointer;
type value_type (line 257) | typedef const value_type* const_pointer;
type value_type (line 258) | typedef value_type& reference;
type value_type (line 259) | typedef const value_type& const_reference;
type size_type (line 260) | typedef size_t size_type;
type difference_type (line 261) | typedef ptrdiff_t difference_type;
type __deque_iterator (line 265) | typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
type __deque_iterator (line 266) | typedef __deque_iterator<T, const
type __deque_iterator (line 268) | typedef __deque_iterator<T, T&, T*> iterator;
type __deque_iterator (line 269) | typedef __deque_iterator<T, const
type reverse_iterator (line 273) | typedef reverse_iterator<const_iterator> const_reverse_iterator;
type reverse_iterator (line 274) | typedef reverse_iterator<iterator> reverse_iterator;
type reverse_iterator (line 276) | typedef reverse_iterator<const_iterator, value_type, const_reference,
type reverse_iterator (line 279) | typedef reverse_iterator<iterator, value_type, reference, difference_type>
type simple_alloc (line 285) | typedef simple_alloc<value_type, Alloc> data_allocator;
type simple_alloc (line 286) | typedef simple_alloc<pointer, Alloc> map_allocator;
function size_type (line 288) | static size_type buffer_size() {
function size_type (line 291) | static size_type initial_map_size() { return 8; }
function iterator (line 302) | iterator end() { return finish; }
function reverse_iterator (line 306) | reverse_iterator rbegin() { return reverse_iterator(finish); }
function reverse_iterator (line 307) | reverse_iterator rend() { return reverse_iterator(start); }
function reference (line 315) | reference operator[](size_type n) { return start[difference_type(n)]; }
function const_reference (line 316) | const_reference operator[](size_type n) const {
function reference (line 320) | reference front() { return *start; }
function reference (line 321) | reference back() {
function swap (line 430) | void swap(deque& x) {
function push_front (line 448) | void push_front(const value_type& t) {
function pop_back (line 457) | void pop_back() {
function pop_front (line 466) | void pop_front() {
function iterator (line 493) | iterator insert(iterator position) { return insert(position, value_type(...
function insert (line 497) | void insert(iterator pos, int n, const value_type& x) {
function insert (line 500) | void insert(iterator pos, long n, const value_type& x) {
function resize (line 518) | void resize(size_type new_size, const value_type& x) {
function resize (line 526) | void resize(size_type new_size) { resize(new_size, value_type()); }
function iterator (line 606) | iterator reserve_elements_at_front(size_type n) {
function iterator (line 613) | iterator reserve_elements_at_back(size_type n) {
function pointer (line 644) | pointer allocate_node() { return data_allocator::allocate(buffer_size()); }
function deallocate_node (line 645) | void deallocate_node(pointer n) {
FILE: tass-sgi-stl-2.91.57-source/stl_function.h
type unary_function (line 37) | struct unary_function {
type Arg1 (line 44) | typedef Arg1 first_argument_type;
type Arg2 (line 45) | typedef Arg2 second_argument_type;
type Result (line 46) | typedef Result result_type;
function T (line 75) | T operator()(const T& x, const T& y) const { return x % y; }
function T (line 80) | T operator()(const T& x) const { return -x; }
function const (line 85) | bool operator()(const T& x, const T& y) const { return x == y; }
function const (line 90) | bool operator()(const T& x, const T& y) const { return x != y; }
function const (line 95) | bool operator()(const T& x, const T& y) const { return x > y; }
function const (line 100) | bool operator()(const T& x, const T& y) const { return x < y; }
function const (line 105) | bool operator()(const T& x, const T& y) const { return x >= y; }
function const (line 110) | bool operator()(const T& x, const T& y) const { return x <= y; }
function const (line 115) | bool operator()(const T& x, const T& y) const { return x && y; }
function const (line 120) | bool operator()(const T& x, const T& y) const { return x || y; }
function const (line 125) | bool operator()(const T& x) const { return !x; }
function const (line 135) | bool operator()(const typename Predicate::argument_type& x) const {
function const (line 154) | bool operator()(const typename Predicate::first_argument_type& x,
function typename (line 176) | typename Operation::result_type
type typename (line 184) | typedef typename Operation::first_argument_type arg1_type;
function typename (line 199) | typename Operation::result_type
type typename (line 207) | typedef typename Operation::second_argument_type arg2_type;
function typename (line 219) | typename Operation1::result_type
function typename (line 242) | typename Operation1::result_type
function explicit (line 260) | explicit pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {}
function Result (line 261) | Result operator()(Arg x) const { return ptr(x); }
function explicit (line 275) | explicit pointer_to_binary_function(Result (*x)(Arg1, Arg2)) : ptr(x) {}
function Result (line 276) | Result operator()(Arg1 x, Arg2 y) const { return ptr(x, y); }
function Arg2 (line 313) | Arg2 operator()(const Arg1&, const Arg2& y) const { return y; }
type Result (line 319) | typedef Result result_type;
function val (line 321) | constant_void_fun(const result_type& v) : val(v) {}
function val (line 332) | constant_unary_fun(const Result& v) : val(v) {}
function Result (line 333) | const Result& operator()(const Argument&) const { return val; }
function val (line 343) | constant_binary_fun(const Result& v) : val(v) {}
function Result (line 344) | const Result& operator()(const Arg1&, const Arg2&) const {
function initialize (line 381) | void initialize(unsigned int seed)
function S (line 434) | S operator()(T* p) const { return (p->*f)(); }
function S (line 443) | S operator()(const T* p) const { return (p->*f)(); }
function S (line 453) | S operator()(T& r) const { return (r.*f)(); }
function S (line 462) | S operator()(const T& r) const { return (r.*f)(); }
function S (line 480) | S operator()(const T* p, A x) const { return (p->*f)(x); }
function explicit (line 488) | explicit mem_fun1_ref_t(S (T::*pf)(A)) : f(pf) {}
function S (line 489) | S operator()(T& r, A x) const { return (r.*f)(x); }
function S (line 498) | S operator()(const T& r, A x) const { return (r.*f)(x); }
function explicit (line 508) | explicit mem_fun_t(void (T::*pf)()) : f(pf) {}
function const (line 509) | void operator()(T* p) const { (p->*f)(); }
function explicit (line 517) | explicit const_mem_fun_t(void (T::*pf)() const) : f(pf) {}
function const (line 518) | void operator()(const T* p) const { (p->*f)(); }
function explicit (line 526) | explicit mem_fun_ref_t(void (T::*pf)()) : f(pf) {}
function const (line 527) | void operator()(T& r) const { (r.*f)(); }
function explicit (line 535) | explicit const_mem_fun_ref_t(void (T::*pf)() const) : f(pf) {}
function const (line 536) | void operator()(const T& r) const { (r.*f)(); }
function explicit (line 544) | explicit mem_fun1_t(void (T::*pf)(A)) : f(p
Condensed preview — 535 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,500K chars).
[
{
"path": "stl-3.3-source/algo.h",
"chars": 3182,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/algobase.h",
"chars": 2086,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/algorithm",
"chars": 1368,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/alloc.h",
"chars": 1310,
"preview": "/*\n * Copyright (c) 1996-1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/bitset",
"chars": 32818,
"preview": "/*\n * Copyright (c) 1998\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/bvector.h",
"chars": 1497,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/char_traits.h",
"chars": 4137,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/concept_checks.h",
"chars": 28902,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/container_concepts.h",
"chars": 9505,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/defalloc.h",
"chars": 2331,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/deque",
"chars": 1380,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/deque.h",
"chars": 1403,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/function.h",
"chars": 3327,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/functional",
"chars": 762,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/hash_map",
"chars": 1330,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/hash_map.h",
"chars": 1516,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/hash_set",
"chars": 1330,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/hash_set.h",
"chars": 1474,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/hashtable.h",
"chars": 1559,
"preview": "/*\n * Copyright (c) 1996,1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/heap.h",
"chars": 1427,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/iterator",
"chars": 1513,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/iterator.h",
"chars": 2998,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/limits",
"chars": 20687,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/list",
"chars": 1351,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/list.h",
"chars": 1373,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/map",
"chars": 1329,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/map.h",
"chars": 1453,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/memory",
"chars": 3525,
"preview": "/*\n * Copyright (c) 1997-1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/multimap.h",
"chars": 1478,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/multiset.h",
"chars": 1478,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/numeric",
"chars": 1556,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/pair.h",
"chars": 1518,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/pthread_alloc",
"chars": 16188,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/pthread_alloc.h",
"chars": 866,
"preview": "/*\n * Copyright (c) 1996-1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/queue",
"chars": 1475,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/rope",
"chars": 924,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/rope.h",
"chars": 909,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/ropeimpl.h",
"chars": 48471,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/sequence_concepts.h",
"chars": 7100,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/set",
"chars": 1329,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/set.h",
"chars": 1453,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/slist",
"chars": 807,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/slist.h",
"chars": 830,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stack",
"chars": 1378,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stack.h",
"chars": 1466,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stdexcept",
"chars": 2391,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl-3.3.SearchResults",
"chars": 1187,
"preview": "---- pop_heap Matches (18 in 5 files) ----\nAlgo.h:using __STD::pop_heap;\nHeap.h:using __STD::pop_heap;\nStl_algo.h: "
},
{
"path": "stl-3.3-source/stl_algo.h",
"chars": 113242,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_algobase.h",
"chars": 24334,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_alloc.h",
"chars": 29001,
"preview": "/*\n * Copyright (c) 1996-1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/stl_bvector.h",
"chars": 27207,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_config.h",
"chars": 20960,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_construct.h",
"chars": 3639,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_ctraits_fns.h",
"chars": 2160,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_deque.h",
"chars": 53591,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_exception.h",
"chars": 1715,
"preview": "/*\n * Copyright (c) 1998\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_function.h",
"chars": 22860,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_hash_fun.h",
"chars": 2818,
"preview": "/*\n * Copyright (c) 1996-1998\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/stl_hash_map.h",
"chars": 20496,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_hash_set.h",
"chars": 19611,
"preview": "/*\n * Copyright (c) 1996\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_hashtable.h",
"chars": 33026,
"preview": "/*\n * Copyright (c) 1996,1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/stl_heap.h",
"chars": 10097,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_iterator.h",
"chars": 30011,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_iterator_base.h",
"chars": 12213,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_list.h",
"chars": 25927,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_map.h",
"chars": 10688,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_multimap.h",
"chars": 10638,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_multiset.h",
"chars": 9640,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_numeric.h",
"chars": 8120,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_pair.h",
"chars": 2975,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_queue.h",
"chars": 7529,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_range_errors.h",
"chars": 2167,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics\n *\n * Permission to use, copy, modify, distribute and sell this software\n *"
},
{
"path": "stl-3.3-source/stl_raw_storage_iter.h",
"chars": 2595,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_relops.h",
"chars": 1828,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_rope.h",
"chars": 99883,
"preview": "/*\n * Copyright (c) 1997-1998\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/stl_set.h",
"chars": 9460,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_slist.h",
"chars": 32237,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_stack.h",
"chars": 4301,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_string_fwd.h",
"chars": 1114,
"preview": "/*\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/stl_tempbuf.h",
"chars": 4897,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_threads.h",
"chars": 12731,
"preview": "/*\n * Copyright (c) 1997-1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/stl_tree.h",
"chars": 44695,
"preview": "/*\n *\n * Copyright (c) 1996,1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distr"
},
{
"path": "stl-3.3-source/stl_uninitialized.h",
"chars": 9355,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/stl_vector.h",
"chars": 28603,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/string",
"chars": 76207,
"preview": "/*\n * Copyright (c) 1997-1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribu"
},
{
"path": "stl-3.3-source/tempbuf.h",
"chars": 1898,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/tree.h",
"chars": 1423,
"preview": "/*\n *\n * Copyright (c) 1996,1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distr"
},
{
"path": "stl-3.3-source/type_traits.h",
"chars": 12934,
"preview": "/*\n *\n * Copyright (c) 1997\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute"
},
{
"path": "stl-3.3-source/utility",
"chars": 1301,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/valarray",
"chars": 52988,
"preview": "/*\n * Copyright (c) 1999\n * Silicon Graphics Computer Systems, Inc.\n *\n * Permission to use, copy, modify, distribute an"
},
{
"path": "stl-3.3-source/vector",
"chars": 1409,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-3.3-source/vector.h",
"chars": 1408,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-gatieme/1-stl_config/1config-inclass-init.cpp",
"chars": 380,
"preview": "//̬ʼ\r\n#include <iostream>\r\nusing namespace std;\r\n\r\ntemplate <typename T>\r\nclass testClass\r\n{\r\n\r\npublic:\r\n\r\n static co"
},
{
"path": "stl-gatieme/1-stl_config/1config-operator-overloading.cpp",
"chars": 1166,
"preview": "//Լȡֵ\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nclass INT\r\n{\r\n friend ostream& operator<<(ostream& os, const INT&"
},
{
"path": "stl-gatieme/1-stl_config/1config-template-exp-special.cpp",
"chars": 620,
"preview": "//class template explicit specializatin \r\n#include <iostream> \r\nusing namespace std; \r\n \r\ntemplate <class Key> \r\nst"
},
{
"path": "stl-gatieme/1-stl_config/1config-temporary-object.cpp",
"chars": 380,
"preview": "//ʱIJ\r\n#include <vector>\r\n#include <iostream>\r\n#include <algorithm>\r\nusing namespace std;\r\n\r\ntemplate <typename T>\r\nclass"
},
{
"path": "stl-gatieme/1-stl_config/1config.cpp",
"chars": 6335,
"preview": "#include <iostream>\r\n#include <stdio.h>\r\nusing namespace std;\r\n\r\n\r\nvoid test(void)\r\n{\r\n#ifdef _PTHREADS\r\n cout<<\"d"
},
{
"path": "stl-gatieme/1-stl_config/1config10.cpp",
"chars": 514,
"preview": "//template ɷǰһtemplate趨Ĭֵ \r\n#include <iostream> \r\n#include <cstddef> \r\n \r\nusing namespace std; \r\n \r\nclass alloc \r"
},
{
"path": "stl-gatieme/1-stl_config/1config11.cpp",
"chars": 929,
"preview": "//class template ɷӵnon-type template \r\n#include <iostream> \r\n#include <cstddef> \r\nusing namespace std; \r\n \r\nclass a"
},
{
"path": "stl-gatieme/1-stl_config/1config2.cpp",
"chars": 1011,
"preview": "\r\n#include <iostream>\r\n#include <vector>\r\n\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n# if defined(__sgi)\r\n cout << \"__sig\""
},
{
"path": "stl-gatieme/1-stl_config/1config3.cpp",
"chars": 773,
"preview": "//class templateӵstatic data members. \r\n#include <iostream> \r\nusing namespace std; \r\n \r\ntemplate <typename T> \r\ncla"
},
{
"path": "stl-gatieme/1-stl_config/1config5.cpp",
"chars": 605,
"preview": "//class template ָconst֧ \r\n#include <iostream> \r\nusing namespace std; \r\n \r\ntemplate <class I, class O> \r\nstruct tes"
},
{
"path": "stl-gatieme/1-stl_config/1config8.cpp",
"chars": 612,
"preview": "//class template ֮ڿɷtemplate (members) \r\n#include <iostream> \r\nusing namespace std; \r\n \r\nclass alloc \r\n{ \r\n}; \r\n "
},
{
"path": "stl-gatieme/1-stl_config/1functor.cpp",
"chars": 649,
"preview": "//STL采用仿函数排序\r\n#include <iostream>\r\nusing namespace std;\r\n\r\n\r\n// 由于将operator()重载了, 因此plus成了一个仿函数\r\ntemplate <class T>\r\nst"
},
{
"path": "stl-gatieme/1-stl_config/1qsort.cpp",
"chars": 626,
"preview": "#include <cstdlib>\r\n#include <iostream>\r\n\r\n\r\nusing namespace std;\r\n\r\n\r\nint fcmp(const void *elem1, const void *elem2);\r\n"
},
{
"path": "stl-gatieme/1-stl_config/Makefile",
"chars": 1025,
"preview": "ROOT=..\nPLATFORM=$(shell $(ROOT)/systype.sh)\ninclude $(ROOT)/Make.defines.$(PLATFORM)\n\ntarget=1config 1config2 1config3 "
},
{
"path": "stl-gatieme/1-stl_config/stl_config.h",
"chars": 22738,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-gatieme/2-defalloc/2jjalloc.h",
"chars": 1738,
"preview": " //file: 2jjalloc.h\n\n#ifndef _JJALLOC_\n\n#define _JJALLOC_\n\n#include <new> \t\t\t// for placement new \n#include <cstddef>"
},
{
"path": "stl-gatieme/2-defalloc/Makefile",
"chars": 554,
"preview": "ROOT=../../..\nPLATFORM=$(shell $(ROOT)/systype.sh)\ninclude $(ROOT)/Make.defines.$(PLATFORM)\n\ntarget=constructor copycons"
},
{
"path": "stl-gatieme/2-defalloc/README.md",
"chars": 68,
"preview": "[ ռSTLԴ](http://blog.csdn.net/chinajane163/article/details/50148073)"
},
{
"path": "stl-gatieme/2-defalloc/defalloc.h",
"chars": 2472,
"preview": "/*\n *\n * Copyright (c) 1994\n * Hewlett-Packard Company\n *\n * Permission to use, copy, modify, distribute and sell this s"
},
{
"path": "stl-gatieme/2-defalloc/simple_jjallocator.h",
"chars": 4658,
"preview": "#ifndef SIMPLE_JJALLOC_H \n#define SIMPLE_JJALLOC_H \n#include<new> //for placement new \n#include<cstddef> //f"
},
{
"path": "stl-gatieme/2-defalloc/stl_alloc.h",
"chars": 23731,
"preview": "// Filename: stl_alloc.h \n \n\n \n// ر˵: SGI STLallocatorҵı뻷²ʹڴ \n// ڴزڴͷŲ, ͷʱΪ˳stack unwinding \n// "
},
{
"path": "stl-gatieme/2-defalloc/test.cpp",
"chars": 527,
"preview": "#include \"simple_jjalloc.h\" \n\n#include<vector> \n#include<iostream> \n\nusing namespace std; \n\n\t\nint main() \n{ \n {"
},
{
"path": "stl-gatieme/3-iterator/3autoptr.cpp",
"chars": 3145,
"preview": "#include <iostream>\n#include <string>\n\n\n#include <typeinfo>\nusing namespace std;\n\n#if defined(__SGI_STL_USE_AutoPtr_CONV"
},
{
"path": "stl-gatieme/3-iterator/3find.cpp",
"chars": 984,
"preview": "#include <iostream>\n#include <vector>\n#include <deque>\n#include <list>\n#include <algorithm>\n\n\nusing namespace std;\n\nint "
},
{
"path": "stl-gatieme/3-iterator/3function_template1.cpp",
"chars": 402,
"preview": "///c++11 1ģƵ\n///http://blog.csdn.net/coolmeme/article/details/43986163\n///http://blog.csdn.net/shinehoo/article/details/"
},
{
"path": "stl-gatieme/3-iterator/3function_template2.cpp",
"chars": 636,
"preview": "///c++11 1ģƵ\n///http://blog.csdn.net/coolmeme/article/details/43986163\n///http://blog.csdn.net/shinehoo/article/details/"
},
{
"path": "stl-gatieme/3-iterator/3function_template3.cpp",
"chars": 1510,
"preview": "///c++11 1ģƵ\n///http://blog.csdn.net/coolmeme/article/details/43986163\n///http://blog.csdn.net/shinehoo/article/details/"
},
{
"path": "stl-gatieme/3-iterator/3mylist.h",
"chars": 726,
"preview": "#ifndef __MYLIST_H__\n#define __MYLIST_H__\n\n#include <iostream>\n#include <ostream>\n#include <vector>\n#include <deque>\n#in"
},
{
"path": "stl-gatieme/3-iterator/3mylist_iter.h",
"chars": 1241,
"preview": "#ifndef __MYLIST_ITER_H__\n#define __MYLIST_ITER_H__\n\n#include <iostream>\n#include <vector>\n#include <deque>\n#include <"
},
{
"path": "stl-gatieme/3-iterator/3mylist_iter_stl.h",
"chars": 408,
"preview": "#ifndef __MYLIST_ITER_H__\n#define __MYLIST_ITER_H__\n\n#include <iostream>\n#include <vector> "
},
{
"path": "stl-gatieme/3-iterator/3mylist_iter_test.cpp",
"chars": 1094,
"preview": "/*************************************************************************\n > File Name: 3mylist-iter-test.cpp\n > "
},
{
"path": "stl-gatieme/3-iterator/3tag_test.cpp",
"chars": 577,
"preview": "#include <iostream>\nusing namespace std;\n\nstruct B /// B ɱΪInputIterator\n{\n\n};\n\nstruct D1 : public B "
},
{
"path": "stl-gatieme/3-iterator/3templatespecial_class.cpp",
"chars": 1216,
"preview": "#include <iostream>\n#include <cstring>\n#include <cmath>\n// general version\ntemplate<class T>\nclass Compare\n{\npublic:\n "
},
{
"path": "stl-gatieme/3-iterator/3templatespecial_func.cpp",
"chars": 920,
"preview": "#include <iostream>\n#include <cstring>\n\n/// ģػ\n\ntemplate <class T>\nint compare(const T left, const T right)\n{\n std::"
},
{
"path": "stl-gatieme/3-iterator/3test_typeid.cpp",
"chars": 748,
"preview": "/*************************************************************************\n > File Name: 3typeif.cpp\n > Author: ga"
},
{
"path": "stl-gatieme/3-iterator/Makefile",
"chars": 648,
"preview": "ROOT=..\nPLATFORM=$(shell $(ROOT)/systype.sh)\ninclude $(ROOT)/Make.defines.$(PLATFORM)\n\ntarget=3autoptr 3find test_auto_p"
},
{
"path": "stl-gatieme/3-iterator/test_auto_ptr.cpp",
"chars": 868,
"preview": "#include <memory>\n#include <iostream>\nusing namespace std;\n\nclass A\n{\npublic:\n A( )\n {\n id = ++count;\n "
},
{
"path": "stl-gatieme/3-iterator/test_bad_typeid.cpp",
"chars": 369,
"preview": "// expre_bad_typeid.cpp\n\n#include <typeinfo>\n#include <iostream>\n\nusing namespace std;\n\nclass A\n{\npublic:\n // object fo"
},
{
"path": "stl-gatieme/3-iterator/typeinfo.h",
"chars": 7205,
"preview": "// cp /usr/include/c++/4.4.4/typeinfo ./typeinfo.h\n// RTTI support for -*- C++ -*-\n// Copyright (C) 1994, 1995, 1996, 1"
},
{
"path": "stl-gatieme/4-sequence-containers/4deque_test.cpp",
"chars": 463,
"preview": "#include <iostream>\n#include <algorithm>\n#include <deque>\n#include <iomanip>\n#include <cstdlib>\n\n\nusing namespace std;\nv"
},
{
"path": "stl-gatieme/4-sequence-containers/4heap_test.cpp",
"chars": 1070,
"preview": "#include <iostream>\n#include <algorithm>\n#include <vector>\n#include <iomanip>\n\n\nusing namespace std;\nvoid Print(int a)\n{"
},
{
"path": "stl-gatieme/4-sequence-containers/4queue_test.cpp",
"chars": 711,
"preview": "#include <iostream>\n#include <algorithm>\n\n#include <iomanip>\n#include <cstdlib>\n\n#include <queue>\n#include <list>\n\nusing"
},
{
"path": "stl-gatieme/4-sequence-containers/4stack_test.cpp",
"chars": 703,
"preview": "#include <iostream>\n#include <algorithm>\n\n#include <iomanip>\n#include <cstdlib>\n\n#include <stack>\n#include <list>\n\nusing"
},
{
"path": "stl-gatieme/4-sequence-containers/4vector_reset.cpp",
"chars": 785,
"preview": "#include <iostream>\n#include <algorithm>\n#include <vector>\n#include <iomanip>\n\n\nusing std::cout;\nusing std::endl;\nusing "
},
{
"path": "stl-gatieme/4-sequence-containers/4vector_test.cpp",
"chars": 2444,
"preview": "#include <iostream>\n#include <algorithm>\n#include <vector>\n#include <iomanip>\n\n\nusing namespace std;\nvoid Print(int a)\n{"
},
{
"path": "stl-gatieme/Make.defines.freebsd",
"chars": 528,
"preview": "# Common make definitions, customized for each platform\n\n# Definitions required in all program directories to compile an"
},
{
"path": "stl-gatieme/Make.defines.linux",
"chars": 532,
"preview": "# Common make definitions, customized for each platform\n\n# Definitions required in all program directories to compile an"
},
{
"path": "stl-gatieme/Make.defines.macos",
"chars": 533,
"preview": "# Common make definitions, customized for each platform\n\n# Definitions required in all program directories to compile an"
},
{
"path": "stl-gatieme/Make.defines.solaris",
"chars": 575,
"preview": "# Common make definitions, customized for each platform\n\n# Definitions required in all program directories to compile an"
},
{
"path": "stl-gatieme/Makefile",
"chars": 323,
"preview": "ROOT=.\nPLATFORM=$(shell $(ROOT)/systype.sh)\ninclude $(ROOT)/Make.defines.$(PLATFORM)\n\nDIRS=1-stl_config 2-defalloc 3-it"
},
{
"path": "stl-gatieme/systype.sh",
"chars": 466,
"preview": "# (leading space required for Xenix /bin/sh)\n\n#\n# Determine the type of *ix operating system that we're\n# running on, an"
},
{
"path": "stl侯杰源码/Makefile",
"chars": 289,
"preview": "include Makefile.h\n\nall::\n\nCODE_DIRS = util stl cont iter fo algo string num io i18n memory\nall::\n\t@for DIR in $(CODE_DI"
},
{
"path": "stl侯杰源码/Makefile.h",
"chars": 2770,
"preview": "##################################################################\n# Makefile with general settings for the book \"The C+"
},
{
"path": "stl侯杰源码/README",
"chars": 1572,
"preview": "These are the examples from the following book:\n Nicolai M. Josuttis\n The C++ Standard Library - A Tutorial and Referenc"
},
{
"path": "stl侯杰源码/algo/Makefile",
"chars": 570,
"preview": "OUTPROGS = \\\n\t\tforeach1 foreach2 foreach3 \\\n\t\tcount1 minmax1 \\\n\t\tfind1 find2 \\\n\t\tsearchn1 search1 search2 \\\n\t\tfindend1 f"
},
{
"path": "stl侯杰源码/algo/accu1.cpp",
"chars": 1612,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/adjdiff1.cpp",
"chars": 1349,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/adjfind1.cpp",
"chars": 1608,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/algostuff.hpp",
"chars": 1464,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/bounds1.cpp",
"chars": 1517,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/bsearch1.cpp",
"chars": 1042,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/copy1.cpp",
"chars": 1506,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/copy2.cpp",
"chars": 1345,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/copy3.cpp",
"chars": 798,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/count1.cpp",
"chars": 1392,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/eqrange1.cpp",
"chars": 1081,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/equal1.cpp",
"chars": 1474,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/fill1.cpp",
"chars": 1766,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/find1.cpp",
"chars": 1500,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/find2.cpp",
"chars": 1263,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/findend1.cpp",
"chars": 1470,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/findof1.cpp",
"chars": 1622,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/foreach1.cpp",
"chars": 844,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/foreach2.cpp",
"chars": 1346,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/foreach3.cpp",
"chars": 1379,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/generate.cpp",
"chars": 1035,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/heap1.cpp",
"chars": 1357,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/imerge1.cpp",
"chars": 1004,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/includes.cpp",
"chars": 1114,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/inner1.cpp",
"chars": 1818,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/lexico1.cpp",
"chars": 1696,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/merge1.cpp",
"chars": 975,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/minmax1.cpp",
"chars": 1335,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/misma1.cpp",
"chars": 1778,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/nth1.cpp",
"chars": 1939,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/part1.cpp",
"chars": 1313,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/partsum1.cpp",
"chars": 1059,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/perm1.cpp",
"chars": 1501,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/psort1.cpp",
"chars": 1506,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/psort2.cpp",
"chars": 1516,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/random1.cpp",
"chars": 1439,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/relabs.cpp",
"chars": 1167,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/remove1.cpp",
"chars": 1335,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/remove2.cpp",
"chars": 1514,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/replace1.cpp",
"chars": 1183,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/replace2.cpp",
"chars": 1693,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/reverse1.cpp",
"chars": 1071,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/rotate1.cpp",
"chars": 1398,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/rotate2.cpp",
"chars": 1796,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/search1.cpp",
"chars": 1426,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/search2.cpp",
"chars": 1703,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/searchn1.cpp",
"chars": 1787,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/setalgos.cpp",
"chars": 2234,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/sort1.cpp",
"chars": 936,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/sort2.cpp",
"chars": 1688,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/swap1.cpp",
"chars": 1388,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/transf1.cpp",
"chars": 1499,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
},
{
"path": "stl侯杰源码/algo/transf2.cpp",
"chars": 1812,
"preview": "/* The following code example is taken from the book\n * \"The C++ Standard Library - A Tutorial and Reference\"\n * by Nico"
}
]
// ... and 335 more files (download for full content)
About this extraction
This page contains the full source code of the gatieme/STLSourceAnalysis GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 535 files (2.3 MB), approximately 618.2k tokens, and a symbol index with 3561 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.