Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   File Members  

std::safe_vector< T, Allo > Class Template Reference

#include <safe_vector.h>

Inherits std::vector< T, Allo >.

Inheritance diagram for std::safe_vector:

Inheritance graph
[legend]
Collaboration diagram for std::safe_vector< T, Allo >:

Collaboration graph
[legend]
List of all members.

Public Methods

 safe_vector (unsigned int __n, const T &val)
 safe_vector ()
 safe_vector (unsigned int __n)
 safe_vector (const vector< T, Allo > &v)
const vector< T, Allo > & operator= (const vector< T, Allo > &a)
T & operator[] (unsigned int n)
const T & operator[] (unsigned int n) const
T & at (unsigned int n)
const T & at (unsigned int n) const
void push_back (const T &t)
void push_back ()
vector< T, Allo > & operator= (const vector< T, Allo > &k)
void reserve (unsigned int n)
iterator begin ()
iterator end ()
const_iterator end () const
const_iterator begin () const
iterator erase (iterator a, iterator b)
void swap (safe_vector< T, Allo > &a)
void resize (size_type ns, const T &x)
void resize (size_type ns)
T & back ()
const T & back () const
T & front ()
const T & front () const
void clear ()
iterator erase (iterator a)
iterator insert (iterator positn, const T &t)
iterator insert (iterator positn, unsigned int n, const T &t)
iterator insert (iterator positn)
iterator insert (iterator positn, unsigned int n)

Static Private Methods

int DIE_NOW ()
int temprand ()

Private Attributes

int id

template<class T, class Allo = allocator <T>>
class std::safe_vector< T, Allo >


Constructor & Destructor Documentation

template<class T, class Allo = allocator <T>>
std::safe_vector< T, Allo >::safe_vector unsigned int    __n,
const T &    val
[inline]
 

00016                                                   :vector<T,Allo>(__n,val) {
00017     id=temprand();
00018       }

template<class T, class Allo = allocator <T>>
std::safe_vector< T, Allo >::safe_vector   [inline]
 

00019                      {
00020     id=temprand();
00021       }

template<class T, class Allo = allocator <T>>
std::safe_vector< T, Allo >::safe_vector unsigned int    __n [inline]
 

00022                                     : vector<T,Allo> (__n) {
00023     id=temprand();
00024       }

template<class T, class Allo = allocator <T>>
std::safe_vector< T, Allo >::safe_vector const vector< T, Allo > &    v [inline]
 

00025                                             : vector<T,Allo>(v){
00026     id=temprand();
00027       }


Member Function Documentation

template<class T, class Allo = allocator <T>>
const T& std::safe_vector< T, Allo >::at unsigned int    n const [inline]
 

00036 {return (*((vector <T,Allo> *)this)).at(n);}

template<class T, class Allo = allocator <T>>
T& std::safe_vector< T, Allo >::at unsigned int    n [inline]
 

00035 { return (*((vector <T,Allo> *)this)).at(n); }

template<class T, class Allo = allocator <T>>
const T& std::safe_vector< T, Allo >::back   const [inline]
 

00212                            {
00213       if (size()>0) return ((vector <T,Allo> *)this)->back();      
00214     }

template<class T, class Allo = allocator <T>>
T& std::safe_vector< T, Allo >::back   [inline]
 

00209                {
00210       if (size()>0) return ((vector <T,Allo> *)this)->back();      
00211     }

template<class T, class Allo = allocator <T>>
const_iterator std::safe_vector< T, Allo >::begin   const [inline]
 

00186                                   {
00187     return const_iterator (((const vector<T,Allo> *)this)->begin(),this);
00188       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::begin   [inline]
 

00177                        {
00178     return iterator (((vector<T,Allo>*)this)->begin(),this);
00179       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::clear   [inline]
 

00222                    {
00223     ((vector <T,Allo> *)this)->clear();
00224     id++;
00225       }

template<class T, class Allo = allocator <T>>
int std::safe_vector< T, Allo >::DIE_NOW   [inline, static, private]
 

00005                          {
00006       return *(int*)0;
00007     }

template<class T, class Allo = allocator <T>>
const_iterator std::safe_vector< T, Allo >::end   const [inline]
 

00183                                 {
00184     return const_iterator (((vector<T,Allo>*)this)->end(),this);
00185       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::end   [inline]
 

00180                      {
00181     return iterator (((vector<T,Allo>*)this)->end(),this);
00182       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::erase iterator    a [inline]
 

00226                                   {
00227     a.check_relevance();
00228     id++;
00229     return iterator (((vector <T,Allo> *)this)->erase(a),this);
00230     
00231       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::erase iterator    a,
iterator    b
[inline]
 

00189                                               {
00190     a.check_relevance();
00191     b.check_relevance();
00192     id++;
00193     return iterator (((vector <T,Allo> *)this)->erase(a,b),this);
00194       }

template<class T, class Allo = allocator <T>>
const T& std::safe_vector< T, Allo >::front   const [inline]
 

00218                             {
00219       if (size()>0) return ((vector <T,Allo> *)this)->front();      
00220     }

template<class T, class Allo = allocator <T>>
T& std::safe_vector< T, Allo >::front   [inline]
 

00215                 {
00216       if (size()>0) return ((vector <T,Allo> *)this)->front();      
00217     }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::insert iterator    positn,
unsigned int    n
[inline]
 

00250                                                         {
00251     positn.check_relevance();
00252     vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,n);
00253     id++;
00254     return iterator(i,this);
00255       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::insert iterator    positn [inline]
 

00244                                         {
00245     positn.check_relevance();
00246     vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn);
00247     id++;
00248     return iterator(i,this);
00249       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::insert iterator    positn,
unsigned int    n,
const T &    t
[inline]
 

00238                                                                     {
00239     positn.check_relevance();
00240     vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,n,t);
00241     id++;
00242     return iterator(i,this);
00243       }

template<class T, class Allo = allocator <T>>
iterator std::safe_vector< T, Allo >::insert iterator    positn,
const T &    t
[inline]
 

00232                                                     {
00233     positn.check_relevance();
00234     vector<T,Allo>::iterator i=vector<T,Allo>::insert (positn,t);
00235     id++;
00236     return iterator(i,this);
00237       }

template<class T, class Allo = allocator <T>>
vector<T,Allo>& std::safe_vector< T, Allo >::operator= const vector< T, Allo > &    k [inline]
 

00045                                                             {
00046     *((vector <T,Allo> *)this) = k;
00047     id=temprand();
00048     return k;
00049       }

template<class T, class Allo = allocator <T>>
const vector<T,Allo>& std::safe_vector< T, Allo >::operator= const vector< T, Allo > &    a [inline]
 

00028                                                                    {
00029     *((vector <T,Allo>*)this)=a;
00030     id = temprand();
00031     return a;
00032       }

template<class T, class Allo = allocator <T>>
const T& std::safe_vector< T, Allo >::operator[] unsigned int    n const [inline]
 

00034 {return (*((vector <T,Allo> *)this)).at(n);}

template<class T, class Allo = allocator <T>>
T& std::safe_vector< T, Allo >::operator[] unsigned int    n [inline]
 

00033 { return (*((vector <T,Allo> *)this)).at(n); }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::push_back   [inline]
 

00041                         {
00042     vector<T,Allo>::push_back();
00043     id++;
00044       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::push_back const T &    t [inline]
 

00037                                   {
00038     vector<T,Allo>::push_back(t);
00039     id++;
00040       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::reserve unsigned int    n [inline]
 

00050                                     {
00051     vector<T,Allo>::reserve (n);
00052     id++;
00053       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::resize size_type    ns [inline]
 

00205                                  {
00206     ((vector <T,Allo> *)this)->resize(ns);
00207     id++;
00208       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::resize size_type    ns,
const T &    x
[inline]
 

00201                                               {
00202     ((vector <T,Allo> *)this)->resize(ns,x);
00203     id++;
00204       }

template<class T, class Allo = allocator <T>>
void std::safe_vector< T, Allo >::swap safe_vector< T, Allo > &    a [inline]
 

00195                                           {
00196     temp = id;
00197     id = a.id;
00198     a.id = temp;
00199     ((vector <T,Allo> *)this)->swap (a);
00200       }

template<class T, class Allo = allocator <T>>
int std::safe_vector< T, Allo >::temprand   [inline, static, private]
 

00009                             {
00010     static int seed;
00011     return seed += 319282;
00012       
00013       }


Member Data Documentation

template<class T, class Allo = allocator <T>>
int std::safe_vector< T, Allo >::id [private]
 


The documentation for this class was generated from the following file:
Generated on Mon Jul 7 21:13:57 2003 for Ethereal by doxygen1.2.15