// lib/prec_stl/vector

#pragma ifndef PREC_STL_VECTOR
#pragma define PREC_STL_VECTOR
#pragma link off global PREC_STL_VECTOR;
#pragma link C++ nestedtypedef;
#pragma link C++ nestedclass;
#if defined(G__HP_aCC) || defined(G__SUNPRO_C)
#pragma mask_newdelete 0x1c;
#else
#pragma mask_newdelete 0x10;
#endif

// Imported from ANSI/ISO C++ 1997/Nov draft 
// Got some ideas from Scott Snyder, Fermi-lab
// Modified by Masaharu Goto
// SGI KCC porting by Philippe Canal, Fermi-lab

#include <iterator>
#include <memory>
#include <utility>

#if defined(G__ANSIISOLIB)
template<class T,class Allocator=allocator<T> >
#elif defined(G__GNUC) && !defined(G__KCC)
template<class T,class Allocator=alloc>
#elif defined(G__HPUX)
template<class T,class Allocator=allocator>
#else
template<class T,class Allocator=allocator<T> >
#endif
class vector {
 public:
  typedef T value_type;
#if defined(G__KCC) 
  typedef typename Allocator::pointer		iterator;
  typedef typename Allocator::const_pointer	const_iterator;
  typedef Allocator				allocator_type;
  typedef reverse_iterator<iterator>	        reverse_iterator;
  typedef reverse_iterator<const_iterator>      const_reverse_iterator;
#else
#if !(G__GNUC>=3)
  typedef T* iterator;
  typedef const T* const_iterator;
#else
  typedef vector<T, Allocator> vector_type;
  typedef __normal_iterator<T*, vector_type> iterator;
  typedef __normal_iterator<T*, vector_type> const_iterator;
#endif
#endif
#if (defined(G__GNUC) && !defined(G__KCC)) || defined(G__HPUX)
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
#else
  typedef typename Allocator::pointer pointer;
  typedef typename Allocator::const_pointer const_pointer;
  typedef typename Allocator::reference reference;
  typedef typename Allocator::const_reference const_reference;
  typedef typename Allocator::size_type size_type;
  typedef typename Allocator::difference_type difference_type;
#endif

#if defined(G__KCC)
  // typedef reverse_iterator<iterator> reverse_iterator;
#else
  class reverse_iterator 
#if defined(G__VISUAL)
	: public _Ranit<T,difference_type>
#elif !defined(G__SUNPRO_C)
    	: public random_access_iterator<T,difference_type>
#endif
	{
   public:
    reverse_iterator(const reverse_iterator& x) ;
#if !defined(G__BORLAND) && !defined(G__KCC)
    reverse_iterator& operator=(const reverse_iterator& x) ;
#endif
#if !(G__GNUC>=3) && !defined(G__KCCC)
    T* base() ;
#else
    iterator base() ;
#endif
    T& operator*() const ;
    reverse_iterator& operator++();
    reverse_iterator operator++(int a);
    reverse_iterator& operator--();
    reverse_iterator operator--(int a);
    reverse_iterator operator+(long n);
    reverse_iterator operator-(long n);
    reverse_iterator& operator+=(long n);
    reverse_iterator& operator-=(long n);
    T& operator[](long n) ;
   private:
  };
#endif
  friend bool operator==(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;
  friend bool operator!=(const vector::reverse_iterator& x
                        ,const vector::reverse_iterator& y) const;

  typedef const reverse_iterator const_reverse_iterator;

#if (G__GNUC>=3) || defined(G__KCC)
  friend bool operator==(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
  friend bool operator!=(vector::const_iterator& x
                        ,vector::const_iterator& y) const;
#endif

#if 0
  friend random_access_iterator_tag 
    iterator_category(random_access_iterator<T,vector::difference_type>& x);
  //friend random_access_iterator_tag 
  //iterator_category(vector::reverse_iterator& x);
#endif

  iterator begin(void) ;
  iterator end(void) ;
  reverse_iterator rbegin(void) ;
  reverse_iterator rend(void) ;
#ifdef G__CONSTNESSFLAG
  const_iterator begin(void) const;
  const_iterator end(void) const;
  const_reverse_iterator rbegin(void) const;
  const_reverse_iterator rend(void) const;
#endif
  size_type size(void) const ;
  size_type max_size(void) const ;
  size_type capacity(void) const ;
  bool empty(void) const ;
  T& operator[](size_type n) ;
  vector(void) ;
  vector(size_type n,const T& value=T()) ;
  vector(const vector& x) ;
  vector(const_iterator first,const_iterator last) ;
  ~vector(void) ;
  vector& operator=(const vector& x);
  void reserve(size_type n) ;
  T& front(void) ;
  T& back(void) ;
  void push_back(const T& x) ;
  void swap(vector& x);
  iterator insert(iterator position,const T& x);
  void insert(iterator position,const_iterator first,const_iterator last);
  void insert(iterator position,size_type n,const T& x);
  void pop_back(void) ;
  void erase(iterator position) ;
  void erase(iterator first,iterator last) ;

#if (G__GNUC>=3) || defined(G__KCC)
  // doesn't work on VC++ 5.0
  friend bool operator==(const vector& x, const vector& y);
  friend bool operator< (const vector& x, const vector& y);
  friend bool operator!=(const vector& x, const vector& y);
  friend bool operator> (const vector& x, const vector& y);
  friend bool operator>=(const vector& x, const vector& y);
  friend bool operator<=(const vector& x, const vector& y);
#endif
  // specialized algorithms:
#if !defined(G__GNUC) || defined(G__KCC)
  // doesn't work on egcs
  friend void swap(vector& x, vector& y);
#endif


#ifndef G__NOALGORITHM

  // Generic algorithm
#if defined(G__GNUC) || defined(G__BORLAND) || defined(G__KCC)

  // input iter
  friend vector::iterator 
    find(vector::iterator first,vector::iterator last,const T& value);
  // forward iter
  friend vector::iterator 
    find_end(vector::iterator first1,vector::iterator last1,
	     vector::iterator first2,vector::iterator last2);
  friend vector::iterator 
    find_first_of(vector::iterator first1,vector::iterator last1,
	          vector::iterator first2,vector::iterator last2);
  friend vector::iterator 
    adjacent_find(vector::iterator first,vector::iterator last);
  // input iter
#if !defined(G__BORLAND)
  friend vector::difference_type
    count(vector::iterator first,vector::iterator last,const T& value);
#endif
#if 0
  friend pair<vector::iterator,vector::iterator>
    mismatch(vector::iterator first1,vector::iterator last1,
             vector::iterator first2);
#endif
  friend bool
    equal(vector::iterator first1,vector::iterator last1,
          vector::iterator first2);
  // forward iter
  friend vector::iterator
    search(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    search_n(vector::iterator first,vector::iterator last
             ,vector::size_type count,const T& value);
  // input and output iter -> forward iter
  friend vector::iterator
    copy(vector::iterator first,vector::iterator last,
         vector::iterator result);
  // bidirectional iter
  friend vector::iterator
    copy_backward(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // just value_type
  friend void swap(T& a,T& b);
  // forward iter
  friend vector::iterator
    swap_ranges(vector::iterator first1,vector::iterator last1,
                vector::iterator first2);
  friend void iter_swap(vector::iterator a,vector::iterator b);
  friend void replace(vector::iterator first,vector::iterator last,
                      const T& old_value,const T& new_value);
  // input, output iter -> forward iter
  friend vector::iterator 
    replace_copy(vector::iterator first,vector::iterator last,
                 vector::iterator result,
                 const T& old_value,const T& new_value);
  // forward iter
  friend void
    fill(vector::iterator first,vector::iterator last,const T& value);
#if (G__GNUC>=3) || defined(G__KCC)
  friend void
    fill_n(vector::iterator first,vector::size_type n,const T& value);
#endif
  friend vector::iterator
    remove(vector::iterator first,vector::iterator last,const T& value);
  // input,output iter -> forward iter
  friend vector::iterator
    remove_copy(vector::iterator first,vector::iterator last,
                vector::iterator result,const T& value);
  friend vector::iterator
    unique(vector::iterator first,vector::iterator last);
  friend vector::iterator 
    unique_copy(vector::iterator first,vector::iterator last,
                vector::iterator result);
  friend void reverse(vector::iterator first,vector::iterator last);
  friend vector::iterator
     reverse_copy(vector::iterator first,vector::iterator last,
                  vector::iterator result);
  // forward iter
#if (G__GNUC>=3) || defined(G__KCC)
  friend void rotate(vector::iterator first,vector::iterator mid,
                     vector::iterator last);
#endif
  // forward iter
  friend vector::iterator 
    rotate_copy(vector::iterator first,vector::iterator mid,
                vector::iterator last,vector::iterator result);
  // randomaccess iter
  friend void random_shuffle(vector::iterator first,vector::iterator last);
  // randomaccess iter
  friend void sort(vector::iterator first,vector::iterator last);
  friend void stable_sort(vector::iterator first,vector::iterator last);
  friend void partial_sort(vector::iterator first,vector::iterator mid,
                           vector::iterator last);
  friend vector::iterator
    partial_sort_copy(vector::iterator first,vector::iterator last,
                      vector::iterator result_first,
                      vector::iterator result_last);
  friend void nth_element(vector::iterator first,vector::iterator nth,
                          vector::iterator last);
  // forward iter
  friend vector::iterator 
    lower_bound(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator 
    upper_bound(vector::iterator first,vector::iterator last,const T& value);
#if 0
  friend pair<vector::iterator,vector::iterator>
    equal_range(vector::iterator first,vector::iterator last,const T& value);
#endif
  friend bool binary_search(vector::iterator first,vector::iterator last,
                            const T& value);
  friend vector::iterator merge(vector::iterator first1,vector::iterator last1,
                                vector::iterator first2,vector::iterator last2,
                                vector::iterator result);
  friend void inplace_merge(vector::iterator first,vector::iterator middle,
                            vector::iterator last);
  friend bool includes(vector::iterator first1,vector::iterator last1,
                       vector::iterator first2,vector::iterator last2);
  friend vector::iterator 
    set_union(vector::iterator first1,vector::iterator last1,
              vector::iterator first2,vector::iterator last2,
              vector::iterator result);
  friend vector::iterator 
    set_intersection(vector::iterator first1,vector::iterator last1,
                     vector::iterator first2,vector::iterator last2,
                     vector::iterator result);
  friend vector::iterator 
    set_difference(vector::iterator first1,vector::iterator last1,
                   vector::iterator first2,vector::iterator last2,
                   vector::iterator result);
  friend vector::iterator 
    set_symmetric_difference(vector::iterator first1,vector::iterator last1,
                             vector::iterator first2,vector::iterator last2,
                             vector::iterator result);
  // random access
  friend void push_heap(vector::iterator first,vector::iterator last);
  friend void pop_heap(vector::iterator first,vector::iterator last);
  friend void make_heap(vector::iterator first,vector::iterator last);
  friend void sort_heap(vector::iterator first,vector::iterator last);
  // min,max, just value_type
  friend const T& min(const T& a,const T& b);
  friend const T& max(const T& a,const T& b);
  // forward iter
  friend vector::iterator 
    min_element(vector::iterator first,vector::iterator last);
  friend vector::iterator 
    max_element(vector::iterator first,vector::iterator last);
  // input iter
  friend bool
    lexicographical_compare(vector::iterator first1,vector::iterator last1,
                            vector::iterator first2,vector::iterator last2);
  // bidirectional iter
  friend bool next_permutation(vector::iterator first,vector::iterator last);
  friend bool prev_permutation(vector::iterator first,vector::iterator last);

#elif defined(G__VISUAL)

  friend void reverse(vector::iterator first,vector::iterator last);
  friend void sort(vector::iterator first,vector::iterator last);

  friend vector::iterator 
    find(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator
    search(vector::iterator first1,vector::iterator last1,
           vector::iterator first2,vector::iterator last2);
  friend vector::iterator
    copy(vector::iterator first,vector::iterator last,
         vector::iterator result);
  friend void
    fill(vector::iterator first,vector::iterator last,const T& value);
#if 0
  // this is the limit that VC++ can handle
  friend vector::iterator
    remove(vector::iterator first,vector::iterator last,const T& value);
  friend vector::iterator
    unique(vector::iterator first,vector::iterator last);
#endif

#endif // G__VISUAL,G__GNUC,G__BORLAND

#endif // G__NOALGORITHM

  // iterator_category resolution
  //friend random_access_iterator_tag iterator_category(vector::iterator x);
};


#pragma endif