dyninstAPI/h/BPatch_Vector.h

   1 /*
   2  * Copyright (c) 1996 Barton P. Miller
   3  *
   4  * We provide the Paradyn Parallel Performance Tools (below
   5  * described as Paradyn") on an AS IS basis, and do not warrant its
   6  * validity or performance.  We reserve the right to update, modify,
   7  * or discontinue this software at any time.  We shall have no
   8  * obligation to supply such updates or modifications or any other
   9  * form of support to you.
  10  *
  11  * This license is for research uses.  For such uses, there is no
  12  * charge. We define "research use" to mean you may freely use it
  13  * inside your organization for whatever purposes you see fit. But you
  14  * may not re-distribute Paradyn or parts of Paradyn, in any form
  15  * source or binary (including derivatives), electronic or otherwise,
  16  * to any other organization or entity without our permission.
  17  *
  18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
  19  *
  20  * All warranties, including without limitation, any warranty of
  21  * merchantability or fitness for a particular purpose, are hereby
  22  * excluded.
  23  *
  24  * By your use of Paradyn, you understand and agree that we (or any
  25  * other person or entity with proprietary rights in Paradyn) are
  26  * under no obligation to provide either maintenance services,
  27  * update services, notices of latent defects, or correction of
  28  * defects for Paradyn.
  29  *
  30  * Even if advised of the possibility of such damages, under no
  31  * circumstances shall we (or any other person or entity with
  32  * proprietary rights in the software licensed hereunder) be liable
  33  * to you or any third party for direct, indirect, or consequential
  34  * damages of any character regardless of type of action, including,
  35  * without limitation, loss of profits, loss of use, loss of good
  36  * will, or computer failure or malfunction.  You agree to indemnify
  37  * us (and any other person or entity with proprietary rights in the
  38  * software licensed hereunder) for any and all liability it may
  39  * incur to third parties resulting from your use of Paradyn.
  40  */
  41
  42 // $Id: BPatch_Vector.h,v 1.12 2002/06/17 17:04:04 gaburici Exp $
  43
  44 #ifndef _BPatch_Vector_h_
  45 #define _BPatch_Vector_h_
  46
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <assert.h>
  50 #include "BPatch_dll.h"
  51
  52 #ifdef USE_STL_VECTOR
  53 #include <stl.h>
  54 #include <vector>
  55 #include <algorithm>
  56
  57 #define BPatch_Vector   vector
  58
  59 #else
  60 #ifdef external_templates
  61 #pragma interface
  62 #endif /* external_templates */
  63
  64 /*
  65  * This causes problems when including this file in code that uses STL,
  66  * so I'm taking it out for now.  - brb
  67 #ifndef BPATCH_LIBRARY
  68 #define vector  BPatch_Vector
  69 #endif
  70  */
  71
  72 template<class T>
  73 class BPATCH_DLL_EXPORT BPatch_Vector {
  74     int         reserved;       // Number of objects for which space is reserved
  75     int         len;            // The current number of objects in the vector
  76     T*          data;           // Points to the array of objects
  77
  78     void        reserve(int n);
  79     inline void copy_from(const BPatch_Vector &);
  80 public:
  81     BPatch_Vector(int n = 0);
  82     BPatch_Vector(const BPatch_Vector<T> &);
  83     ~BPatch_Vector();
  84
  85     BPatch_Vector<T>& operator=(const BPatch_Vector<T> &);
  86
  87     unsigned int size() const { return len; }
  88     void        push_back(const T& x);
  89     void        push_front(const T& x);
  90
  91     T&          operator[](int n) const;
  92 };
  93
  94 // VG(06/15/02): VC.NET doesn't like definitions for dll imports
  95 #ifndef BPATCH_DLL_IMPORT
  96
  97 // Reserve space for at least n entries in the vector
  98 template<class T>
  99 void BPatch_Vector<T>::reserve(int n)
 100 {
 101     if (n > reserved) { // If we haven't already reserved enough space
 102         // Generally we double the size each time we reserve memory, so
 103         // that we're not doing it for every insertion.
 104         if (reserved*2 > n) n = reserved*2;
 105
 106         // Create a new array with enough space
 107         T* new_data = new T[n];
 108
 109         // Copy the entries from the old array to the new one
 110         for (int i = 0; i < len; i++)
 111             new_data[i] = data[i];
 112
 113         // Get rid of the old array and set up to use the new one
 114         if( data != NULL ) delete [] data;
 115         data = new_data;
 116         reserved = n;
 117     }
 118     assert(data != NULL || n == 0);
 119 }
 120
 121 // Copy the contents of another vector into this one.
 122 template<class T>
 123 inline void BPatch_Vector<T>::copy_from(const BPatch_Vector &src)
 124 {
 125     reserved = src.reserved;
 126     len      = src.len;
 127         if( reserved == 0 )
 128                 data = NULL;
 129         else {
 130                 data     = new T[reserved];
 131
 132                 for (int i = 0; i < src.len; i++)
 133                         data[i] = src.data[i];
 134         }
 135 }
 136
 137 // Contructor.  Takes one optional parameter, the number of entries for which
 138 // to reserve space.
 139 template<class T>
 140 BPatch_Vector<T>::BPatch_Vector(int n) : reserved(0), len(0), data(NULL)
 141 {
 142     assert(n >= 0);
 143     if (n > 0) reserve(n);
 144 }
 145
 146 // Copy constructor.
 147 template<class T>
 148 BPatch_Vector<T>::BPatch_Vector(const BPatch_Vector<T> &src)
 149 {
 150     copy_from(src);
 151 }
 152
 153 // Destructor.  Frees allocated memory.
 154 template<class T>
 155 BPatch_Vector<T>::~BPatch_Vector()
 156 {
 157         if( data != NULL ) delete [] data;
 158 }
 159
 160 // Assignment operator.  Delete the contents of this vector and copy the
 161 // contents of the other vector into it.
 162 template<class T>
 163 BPatch_Vector<T>& BPatch_Vector<T>::operator=(const BPatch_Vector<T> &src)
 164 {
 165         if( data != NULL ) delete [] data;
 166
 167     copy_from(src);
 168
 169     return *this;
 170 }
 171
 172 // Add an element to the end of the vector.
 173 template<class T>
 174 void BPatch_Vector<T>::push_back(const T& x)
 175 {
 176     reserve(len+1);
 177     data[len] = x;
 178     len++;
 179 }
 180
 181 // Add an element to the end of the vector.
 182 template<class T>
 183 void BPatch_Vector<T>::push_front(const T& x)
 184 {
 185     int i;
 186
 187     reserve(len+1);
 188     for (i=len; i > 0; i--) data[i] = data[i-1];
 189     data[0] = x;
 190     len++;
 191 }
 192
 193 // Reference the nth element of the vector.
 194 template<class T>
 195 T& BPatch_Vector<T>::operator[](int n) const
 196 {
 197     assert(data != NULL && n >= 0 && n < len);
 198     return data[n];
 199 }
 200
 201 #endif /* BPATCH_DLL_IMPORT */
 202 #endif /* USE_STL_VECTOR */
 203 #endif /* _BPatch_Vector_h_ */