---

ResizeArray.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2011 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: ResizeArray.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.45 $       $Date: 2010/12/16 04:08:38 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *   Automatically-adjusting single-dim array template.
 * 
 * LICENSE:
 *   UIUC Open Source License
 *   http://www.ks.uiuc.edu/Research/vmd/plugins/pluginlicense.html
 *
 ***************************************************************************/
#ifndef RESIZEARRAY_TEMPLATE_H
#define RESIZEARRAY_TEMPLATE_H

#include <string.h>

template<class T>
class ResizeArray {
private:
  T *allocate(size_t n) { return new T[n]; }
  void deallocate(T *p) { delete [] p; }

  T *data;      
  int sz;       
  int currSize; 

public:
  ResizeArray(int s = 3) {
    currSize = 0;
    sz = (s > 0 ? s : 10);
    data = allocate(sz); 
  }

  ~ResizeArray() {
    deallocate(data);
  }
  
  int num(void) const { return currSize; } 
  T& operator[](int N) { return data[N]; } 
  T const& operator[](int N) const { return data[N]; } 

  void append(const T& val) {
    if (currSize == sz) {    // extend size of array if necessary
      int newsize = (int)((float)sz * 1.3f);

      // guarantee minimum required size increase, since the scaled value
      // may truncate back to the original size value when the initial number
      // of elements is very small.
      if (newsize == sz)
        newsize++;

      // shallow copy the data to a newly allocated block since we can't
      // do something better like realloc()
      T *newdata = allocate(newsize); 
      memcpy(newdata, data, currSize * sizeof(T));
      deallocate(data); 
    
      // save new values
      data = newdata;
      sz = newsize;
    }
    data[currSize++] = val;
  }

  void remove(int n) {
    if (n < 0 || n >= currSize) return;
    for (int i=n; i<currSize-1; i++)
      data[i] = data[i+1];
    currSize--;
  }

  T& pop() {
    currSize--;
    return data[currSize]; 
  }

  void clear() {
    currSize = 0;
  }

  void truncatelastn(int N) {
    currSize -= N;
    if (currSize < 0) 
      currSize=0;
  }

  int find(const T& val) {
    int i;
  
    for(i=0; i < currSize; i++) {
      if(data[i] == val) 
        return i;
    }
  
    return -1;
  }
};

#endif

---