CompuCell/DOXYGEN/core/BasicUtils/BasicArray.h

Go to the documentation of this file.

/*******************************************************************\

              Copyright (C) 2003 Joseph Coffland

    This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
                           02111-1307, USA.

            For information regarding this software email
                   jcofflan@users.sourceforge.net

\*******************************************************************/
#ifndef BASICARRAY_H
#define BASICARRAY_H

#include "BasicException.h"

#include <stdlib.h>
#include <string.h>
#include <vector>

#include <iostream>

template <class T>
class BasicArray :public std::vector<T>{
//   unsigned int capacity;D
//   unsigned int size;
//   std::vector<T> vec;
//   T *data;

 public:
  
//      BasicArray() /*: data(0)*/ {
//      using namespace std;
//      cerr<<"DEFAULT CONSTRUCTOR"<<endl;
//              std::vector<T>::clear();
//              cerr<<"vec.size()="<<std::vector<T>::size()<<" getSize()="<<getSize()<<endl;
//      }

  BasicArray(unsigned int initialCapacity=0) /*: data(0)*/ {
//     reset(initialCapacity);
        std::vector<T>::clear();
//      using namespace std;
           if(initialCapacity>0)
                        std::vector<T>::assign(initialCapacity,T());

//              cerr<<"size vector="<<std::vector<T>::size()<<" getSize()="<<getSize()<<endl;
  }

  ~BasicArray() {/*if (data) free(data);*/}


  bool isEmpty() const {return std::vector<T>::size() == 0;}  

  unsigned int getSize() const {return std::vector<T>::size();}

//   void setSize(const unsigned int size) {
//     increase(size);
//     this->size = size;
//   }

  unsigned int getCapacity() const {return std::vector<T>::capacity();}


//  T *getBuffer() {
//    return &((*this)[0]);
//  }

//   T *adopt() {
//     T *tmp = data;
// 
//     data = 0;
//     capacity = 0;
//     size = 0;
// 
//     return tmp;
//   }


//   void reset(unsigned int initialCapacity = 0) {
//     if (data) {
//       free(data);
//       data = 0;
//     }
// 
//     capacity = 0;
//     size = 0;
//     increase(initialCapacity);
//   }

  void clear() {
    std::vector<T>::clear();
  }

//   void increase(const unsigned int minCapacity,
//              const unsigned int multiple = 2) {
//     if (minCapacity <= capacity) return;
//     if (minCapacity < multiple * capacity) capacity *= multiple;
//     else capacity = minCapacity;
//     
//     void *newMem = realloc(data, capacity * sizeof(T));
//     if (!newMem) {
//       if (capacity > minCapacity) capacity = minCapacity;
//       newMem = realloc(data, capacity * sizeof(T));
//       
//       if (!newMem) throw std::bad_alloc();
//     }
// 
//     data = (T *)newMem;
//     memset(&data[size], 0, sizeof(T) * (capacity - size));
//   }

//   void shrink() {
//     if (capacity > size) {
//       data = (T *)realloc(data, size * sizeof(T));
//       capacity = size;
//     }
//   }

  unsigned int put(const T &x) {
         using namespace std;
         std::vector<T>::push_back(x);  
    return std::vector<T>::size()-1;
  }

//   void put(const unsigned int i, const T &x) {
//     put(i, &x, 1);
//   }

//   unsigned int put(const T *x, const int count) {
//     put(getSize(), x, count);
//     return getSize() - count;
//   }

//   void put(const unsigned int i, const T *x, const int count) {
//       using namespace std;
//       cerr<<"i="<<i<<endl;
//       cerr<<"count="<<count<<endl;
//       cerr<<"sizeof(T)="<<sizeof(T)<<endl;
//       cerr<<"x="<<x<<endl;
//       void *dest=alloc(i, count);
//       cerr<<"dest="<<dest<<endl;
//       
//     memcpy(alloc(i, count), x, sizeof(T) * count);
// //    memmove(dest, x, sizeof(T) * count);
//   }

//   void *alloc(const unsigned int count) {
//     return alloc(getSize(), count);
//   }

//   void *alloc(const unsigned int i, const unsigned int count) {
//     increase(i + count);
//     if (size < i + count) size = i + count;
//     return &data[i];
//   }

  T &get(const unsigned int i) {
//       using namespace std;
//     ASSERT_OR_THROW("BasicArray index out of range!", i < std::vector<T>::size());
//       cerr<<"inside GET"<<endl;
    return const_cast<T&>(((*this)[i]));
  }

 BasicArray<T> & operator=(const BasicArray<T> & rhs){
        if(this==&rhs) return *this;
        static_cast<std::vector<T>&>(*this)=rhs;
        return *this;
 }      
//   T &operator[](const unsigned int i) const {
//              using namespace std;
//              cerr<<"inside GET"<<endl;
//              return const_cast<T&>(((*((std::vector<T>)this))[i]));
//      }
};

#endif // BASICARRAY_H

---